การใช้งานของต้นไม้ไบนารีคืออะไร?

ฉันสงสัยว่าแอปพลิเคชันเฉพาะของต้นไม้ไบนารีคืออะไร คุณยกตัวอย่างจริงได้ไหม

การพูดคุยเกี่ยวกับประสิทธิภาพของต้นไม้ไบนารีนั้นไม่มีความหมาย - มันไม่ใช่โครงสร้างข้อมูล แต่เป็นตระกูลของโครงสร้างข้อมูลทั้งหมดที่มีคุณสมบัติด้านประสิทธิภาพแตกต่างกัน ในขณะที่มันเป็นความจริงที่ต้นไม้ไบนารีไม่สมดุลดำเนินการมากยิ่งกว่าตัวเองสมดุลต้นไม้ไบนารีเพื่อการค้นหาที่มีต้นไม้ไบนารีหลาย(เช่นพยายาม binary)ที่"สมดุล"ไม่มีความหมาย

การประยุกต์ของต้นไม้ไบนารี

• แผนผังการค้นหาแบบไบนารี - ใช้ในแอปพลิเคชันการค้นหาจำนวนมากที่มีการป้อน / ออกข้อมูลอย่างต่อเนื่องเช่นmapและsetวัตถุในห้องสมุดหลายภาษา
• Binary Space Partition - ใช้ในเกือบทุกวิดีโอเกม 3D เพื่อกำหนดว่าวัตถุใดที่จำเป็นต้องแสดงผล
• Binary Tries - ใช้ในเราเตอร์ที่มีแบนด์วิดท์สูงเกือบทุกตัวสำหรับจัดเก็บตารางเราเตอร์
• Hash Trees - ใช้ในโปรแกรม p2p และลายเซ็นต์รูปภาพเฉพาะซึ่งจำเป็นต้องมีการตรวจสอบความถูกต้อง แต่ไฟล์ทั้งหมดไม่สามารถใช้งานได้
• Heaps - ใช้ในการดำเนินการจัดลำดับความสำคัญที่มีประสิทธิภาพซึ่งจะใช้สำหรับกระบวนการจัดตารางเวลาในระบบปฏิบัติการหลายระบบคุณภาพบริการในเราเตอร์และ A * (อัลกอริทึมการค้นหาเส้นทางที่ใช้ในแอปพลิเคชั่น AI รวมถึงหุ่นยนต์และวิดีโอเกม) . ยังใช้ในการจัดเรียงกอง
• Huffman Coding Tree ( Chip Uni ) - ใช้ในอัลกอริทึมการบีบอัดเช่นที่ใช้โดย. jpeg และ. mp3 รูปแบบไฟล์
• ต้นไม้ GGM - ใช้ในแอปพลิเคชันเข้ารหัสเพื่อสร้างแผนภูมิของตัวเลขสุ่มหลอก
• ต้นไม้ไวยากรณ์ - สร้างโดยคอมไพเลอร์และ (โดยปริยาย) เครื่องคิดเลขเพื่อแยกวิเคราะห์นิพจน์
• Treap - โครงสร้างข้อมูลแบบสุ่มที่ใช้ในการจัดสรรเครือข่ายไร้สายและหน่วยความจำ
• T-tree - แม้ว่าฐานข้อมูลส่วนใหญ่จะใช้ B-tree บางรูปแบบเพื่อเก็บข้อมูลในไดรฟ์ แต่ฐานข้อมูลที่เก็บข้อมูลทั้งหมด (ส่วนใหญ่) ไว้ในหน่วยความจำมักใช้ T-tree เพื่อทำเช่นนั้น

เหตุผลที่ต้นไม้ไบนารีถูกนำมาใช้บ่อยกว่าต้นไม้ n-ary สำหรับการค้นหาคือต้นไม้ n-ary มีความซับซ้อนมากขึ้น แต่มักจะไม่ได้เปรียบความเร็วที่แท้จริง

ในต้นไม้ไบนารี (สมดุล) ที่มีmโหนดการย้ายจากระดับหนึ่งไปยังอีกระดับหนึ่งนั้นต้องการการเปรียบเทียบหนึ่งรายการและมีหลายlog_2(m)ระดับสำหรับการlog_2(m)เปรียบเทียบทั้งหมด

ในทางตรงกันข้ามต้นไม้ n-ary จะต้องมีlog_2(n)การเปรียบเทียบ(โดยใช้การค้นหาแบบไบนารี)เพื่อเลื่อนไปยังระดับถัดไป เนื่องจากมีlog_n(m)ระดับทั้งหมดการค้นหาจึงจำเป็นต้องมีlog_2(n)*log_n(m)= log_2(m)การเปรียบเทียบทั้งหมด ดังนั้นแม้ว่าต้นไม้ n-ary จะมีความซับซ้อนมากกว่า แต่ก็ไม่ได้เปรียบในแง่ของการเปรียบเทียบทั้งหมดที่จำเป็น

(อย่างไรก็ตามต้นไม้ n-ary ยังคงมีประโยชน์ในสถานการณ์เฉพาะ) ตัวอย่างที่มาในใจคือquad-treesและต้นไม้ที่กั้นพื้นที่อื่น ๆ ซึ่งการแบ่งพื้นที่โดยใช้เพียงสองโหนดต่อระดับจะทำให้ตรรกะซับซ้อนโดยไม่จำเป็นและB-treesใช้ในฐานข้อมูลจำนวนมากซึ่งปัจจัย จำกัด ไม่ได้มีการเปรียบเทียบจำนวนเท่าไรในแต่ละระดับ แต่จำนวนโหนดที่สามารถโหลดได้จากฮาร์ดไดรฟ์ในครั้งเดียว)

เมื่อคนส่วนใหญ่พูดถึงต้นไม้ไบนารีพวกเขามักจะไม่คิดเกี่ยวกับต้นไม้ค้นหาแบบไบนารีดังนั้นฉันจะพูดถึงเรื่องนี้ก่อน

โครงสร้างการค้นหาแบบไบนารี่แบบไม่สมดุลนั้นมีประโยชน์สำหรับการให้ความรู้แก่นักเรียนเกี่ยวกับโครงสร้างข้อมูลเพียงเล็กน้อย นั่นเป็นเพราะหากข้อมูลเข้ามาในลำดับที่ค่อนข้างสุ่มต้นไม้สามารถเสื่อมสภาพลงในรูปแบบที่แย่ที่สุดซึ่งเป็นรายการที่เชื่อมโยงเนื่องจากต้นไม้ไบนารีธรรมดาไม่สมดุลกัน

ในกรณีที่ดี: ฉันเคยต้องแก้ไขซอฟต์แวร์ที่โหลดข้อมูลลงในต้นไม้ไบนารีสำหรับการจัดการและค้นหา มันเขียนข้อมูลออกมาในรูปแบบเรียง:

Alice
Bob
Chloe
David
Edwina
Frank

ดังนั้นเมื่ออ่านกลับมาแล้วจบลงด้วยต้นไม้ต่อไปนี้:

  Alice
 /     \
=       Bob
       /   \
      =     Chloe
           /     \
          =       David
                 /     \
                =       Edwina
                       /      \
                      =        Frank
                              /     \
                             =       =

ซึ่งเป็นรูปแบบที่เสื่อมโทรม หากคุณไปหาแฟรงค์ในต้นไม้คุณจะต้องค้นหาทั้งหกโหนดก่อนที่จะพบเขา

ต้นไม้ไบนารีมีประโยชน์อย่างแท้จริงสำหรับการค้นหาเมื่อคุณสร้างความสมดุล สิ่งนี้เกี่ยวข้องกับการหมุนต้นไม้ย่อยผ่านรูทโหนดเพื่อให้ความแตกต่างของความสูงระหว่างต้นไม้ย่อยสองต้นน้อยกว่าหรือเท่ากับ 1 การเพิ่มชื่อเหล่านั้นไว้ด้านบนทีละครั้งในต้นไม้ที่สมดุลจะทำให้คุณมีลำดับต่อไปนี้:

1.   Alice
    /     \
   =       =

2.   Alice
    /     \
   =       Bob
          /   \
         =     =

3.        Bob
        _/   \_
   Alice       Chloe
  /     \     /     \
 =       =   =       =

4.        Bob
        _/   \_
   Alice       Chloe
  /     \     /     \
 =       =   =       David
                    /     \
                   =       =

5.           Bob
        ____/   \____
   Alice             David
  /     \           /     \
 =       =     Chloe       Edwina
              /     \     /      \
             =       =   =        =

6.              Chloe
            ___/     \___
         Bob             Edwina
        /   \           /      \
   Alice     =      David        Frank
  /     \          /     \      /     \
 =       =        =       =    =       =

คุณสามารถเห็นต้นไม้ย่อยทั้งหมดหมุนไปทางซ้าย (ในขั้นตอนที่ 3 และ 6) เมื่อมีการเพิ่มรายการและสิ่งนี้จะทำให้คุณได้ต้นไม้ไบนารีที่สมดุลซึ่งการค้นหากรณีที่เลวร้ายที่สุดคือO(log N)แทนที่จะเป็นO(N) ที่แบบฟอร์มเลวลง ค่า NULL สูงสุด ( =) จะไม่แตกต่างจากระดับต่ำสุดมากกว่าหนึ่งระดับ และในต้นสุดท้ายข้างต้นคุณสามารถหาแฟรงก์โดยเฉพาะการมองหาที่สามโหนด ( Chloe, Edwinaและในที่สุดFrank)

แน่นอนว่ามันจะมีประโยชน์มากขึ้นเมื่อคุณสร้างต้นไม้หลายทางที่สมดุลแทนที่จะเป็นเลขฐานสอง นั่นหมายความว่าแต่ละโหนดมีมากกว่าหนึ่งรายการ (ในทางเทคนิคพวกเขาเก็บ N items และตัวชี้ N + 1 ซึ่งเป็นต้นไม้ไบนารีเป็นกรณีพิเศษของต้นไม้หลายทางแบบ 1 ทางที่มี 1 รายการและ 2 ตัวชี้)

ด้วยต้นไม้สามทางคุณจะจบลงด้วย:

  Alice Bob Chloe
 /     |   |     \
=      =   =      David Edwina Frank
                 /     |      |     \
                =      =      =      =

โดยปกติจะใช้ในการบำรุงรักษาคีย์สำหรับดัชนีของรายการ ฉันเขียนซอฟต์แวร์ฐานข้อมูลที่ปรับให้เหมาะสำหรับฮาร์ดแวร์ที่มีขนาดเท่ากับบล็อกดิสก์ (เช่น 512 ไบต์) และคุณใส่คีย์ได้มากเท่าที่คุณจะสามารถทำได้ในโหนดเดียว ชี้ในกรณีนี้เป็นจริงการบันทึกหมายเลขเป็นไฟล์โดยตรงเข้าถึงความยาวคงบันทึกแยกออกจากแฟ้มดัชนี (บันทึกหมายเลขดังนั้นXอาจจะพบได้โดยเพียงแค่มองหาที่จะX * record_length)

ตัวอย่างเช่นหากพอยน์เตอร์เป็น 4 ไบต์และขนาดของคีย์คือ 10 จำนวนของคีย์ในโหนด 512- ไบต์คือ 36 นั่นคือ 36 คีย์ (360 ไบต์) และ 37 พอยต์ (148 ไบต์) รวม 508 ไบต์ด้วย 4 ไบต์สูญเปล่าต่อโหนด

การใช้ปุ่มหลายทางแนะนำความซับซ้อนของการค้นหาแบบสองเฟส (การค้นหาแบบหลายทางเพื่อค้นหาโหนดที่ถูกต้องรวมกับการค้นหาแบบลำดับขนาดเล็ก (หรือไบนารีแบบเส้นตรง) เพื่อค้นหาคีย์ที่ถูกต้องในโหนด) แต่ข้อดีใน การทำดิสก์ I / O ให้น้อยกว่าทำเพื่อสิ่งนี้

ฉันไม่เห็นเหตุผลที่จะทำเช่นนี้สำหรับโครงสร้างในหน่วยความจำคุณจะดีกว่าที่จะเกาะต้นไม้ไบนารีที่สมดุลและทำให้รหัสของคุณง่ายขึ้น

โปรดทราบว่าข้อดีของการO(log N)โอเวอร์เกินO(N)นั้นจะไม่ปรากฏเมื่อชุดข้อมูลของคุณมีขนาดเล็ก หากคุณใช้ต้นไม้หลายทางเพื่อจัดเก็บคนสิบห้าคนในสมุดที่อยู่ของคุณ ข้อดีเกิดขึ้นเมื่อคุณจัดเก็บบางอย่างเช่นทุกคำสั่งจากลูกค้าแสนรายในช่วงสิบปีที่ผ่านมา

จุดรวมของสัญกรณ์ใหญ่ -O คือการระบุว่าเกิดอะไรขึ้นเมื่อNอินฟินิตี้ใกล้เข้ามา บางคนอาจไม่เห็นด้วย แต่มันก็โอเคที่จะใช้การเรียงลำดับฟองถ้าคุณแน่ใจว่าชุดข้อมูลจะอยู่ต่ำกว่าขนาดที่กำหนดตราบใดที่ไม่มีสิ่งใดพร้อมใช้งาน :-)

สำหรับการใช้งานอื่น ๆ สำหรับต้นไม้ไบนารีมีจำนวนมากเช่น:

• ฮีปแบบไบนารีที่มีคีย์ที่สูงกว่าหรือเท่ากับหรือต่ำกว่าแทนที่จะอยู่ทางซ้ายของ (หรือต่ำกว่าหรือเท่ากับและขวา);
• ต้นไม้แฮชคล้ายกับตารางแฮช
• ต้นไม้ไวยากรณ์ที่เป็นนามธรรมสำหรับการรวบรวมภาษาคอมพิวเตอร์
• ต้นไม้ของ Huffman สำหรับการบีบอัดข้อมูล
• แผนผังเส้นทางสำหรับการรับส่งข้อมูลเครือข่าย

จากคำอธิบายที่ฉันสร้างขึ้นสำหรับต้นไม้การค้นหาฉันก็ลังเลที่จะพูดถึงรายละเอียดมากมายเกี่ยวกับคนอื่น ๆ แต่นั่นก็เพียงพอแล้วที่จะทำการวิจัยพวกเขาหากคุณต้องการ

องค์กรของรหัสมอร์สเป็นต้นไม้ไบนารี

ทรีไบนารีเป็นโครงสร้างข้อมูลทรีที่แต่ละโหนดมีโหนดรองมากที่สุดสองโหนดโดยปกติจะแยกเป็น "ซ้าย" และ "ขวา" โหนดที่มีลูกคือโหนดพาเรนต์และโหนดลูกอาจมีการอ้างอิงถึงพาเรนต์ ข้างนอกต้นไม้มักจะมีการอ้างอิงถึงโหนด "รูท" (บรรพบุรุษของโหนดทั้งหมด) หากมีอยู่ โหนดใด ๆ ในโครงสร้างข้อมูลสามารถเข้าถึงได้โดยเริ่มต้นที่โหนดรูทและทำตามการอ้างอิงซ้ำกับชายด์ซ้ายหรือขวา ในต้นไม้ไบนารีการศึกษาระดับปริญญาของทุกโหนดเป็นสองสูงสุด

ต้นไม้ไบนารีมีประโยชน์เพราะอย่างที่คุณเห็นในภาพถ้าคุณต้องการหาโหนดใด ๆ ในต้นไม้คุณต้องดูได้สูงสุด 6 ครั้งเท่านั้น หากคุณต้องการค้นหาโหนด 24 คุณจะเริ่มต้นที่รูท

• รูทมีค่า 31 ซึ่งมากกว่า 24 ดังนั้นคุณจึงไปที่โหนดด้านซ้าย
• โหนดด้านซ้ายมีค่า 15 ซึ่งน้อยกว่า 24 ดังนั้นคุณไปที่โหนดด้านขวา
• โหนดด้านขวามีค่า 23 ซึ่งน้อยกว่า 24 ดังนั้นคุณไปที่โหนดขวา
• โหนดด้านขวามีค่า 27 ซึ่งมากกว่า 24 ดังนั้นคุณไปที่โหนดด้านซ้าย
• โหนดด้านซ้ายมีค่าเป็น 25 ซึ่งมากกว่า 24 ดังนั้นคุณจึงไปที่โหนดด้านซ้าย
• โหนดมีค่า 24 ซึ่งเป็นกุญแจสำคัญที่เรากำลังมองหา

การค้นหานี้มีภาพประกอบด้านล่าง:

คุณจะเห็นว่าคุณสามารถยกเว้นโหนดครึ่งหนึ่งของทั้งต้นได้ในการผ่านครั้งแรก และครึ่งหนึ่งของทรีย่อยด้านซ้ายในวินาที ทำให้การค้นหามีประสิทธิภาพมาก หากสิ่งนี้ทำกับองค์ประกอบ4 พันล้านรายการคุณจะต้องค้นหาสูงสุด 32 ครั้งเท่านั้น ดังนั้นยิ่งมีองค์ประกอบในต้นไม้มากเท่าไหร่การค้นหาของคุณก็จะมีประสิทธิภาพมากขึ้นเท่านั้น

การลบอาจซับซ้อน หากโหนดมีลูก 0 หรือ 1 นั่นเป็นเรื่องของการย้ายพอยน์เตอร์บางตัวเพื่อยกเว้นอันที่จะถูกลบ อย่างไรก็ตามคุณไม่สามารถลบโหนดที่มี 2 ลูกได้อย่างง่ายดาย ดังนั้นเราจะตัดสั้น สมมติว่าเราต้องการลบโหนด 19

เนื่องจากการพยายามระบุตำแหน่งที่จะย้ายพอยน์เตอร์ไปทางซ้ายและขวานั้นไม่ใช่เรื่องง่ายเราจึงหาทางแทนที่ เราไปที่ต้นไม้ย่อยด้านซ้ายและไปให้ไกลที่สุดเท่าที่จะทำได้ สิ่งนี้ทำให้เรามีค่ามากที่สุดต่อไปของโหนดที่เราต้องการลบ

ตอนนี้เราคัดลอกเนื้อหาทั้งหมดของ 18 ยกเว้นตัวชี้ซ้ายและขวาและลบ 18 โหนดเดิม

ในการสร้างภาพเหล่านี้ฉันได้ติดตั้งต้นไม้ AVL ซึ่งเป็นต้นไม้ที่ปรับสมดุลตัวเองดังนั้น ณ จุดใดเวลาหนึ่งต้นไม้จึงมีความแตกต่างอย่างมากในระดับหนึ่งระหว่างโหนดใบไม้ (โหนดที่ไม่มีลูก) สิ่งนี้จะป้องกันไม่ให้ต้นไม้กลายเป็นความบิดเบี้ยวและรักษาO(log n)เวลาค้นหาสูงสุดด้วยค่าใช้จ่ายในการแทรกและลบเวลาที่น้อยลง

นี่คือตัวอย่างที่แสดงให้เห็นว่าทรี AVL ของฉันทำให้ตัวเองกะทัดรัดและสมดุลที่สุดเท่าที่จะเป็นไปได้อย่างไร

ในอาร์เรย์เรียงลำดับการค้นหาจะยังคงใช้เวลาO(log(n))เช่นเดียวกับต้นไม้ แต่แทรกสุ่มและการกำจัดจะใช้เวลา O (n) O(log(n))แทนของต้นไม้ คอนเทนเนอร์ STL บางตัวใช้คุณสมบัติประสิทธิภาพเหล่านี้เพื่อประโยชน์ของพวกเขาดังนั้นเวลาในการแทรกและกำจัดจะใช้เวลาสูงสุดO(log n)ซึ่งเร็วมาก บางส่วนของภาชนะเหล่านี้มีmap, multimap, และsetmultiset

โค้ดตัวอย่างสำหรับทรี AVL สามารถดูได้ที่http://ideone.com/MheW8

การประยุกต์ใช้หลักคือต้นไม้ค้นหาแบบทวิภาค เหล่านี้เป็นโครงสร้างข้อมูลที่การค้นหาการแทรกและการลบทั้งหมดนั้นรวดเร็วมาก (เกี่ยวกับlog(n)การทำงาน)

• ต้นไม้ไบนารีถูกใช้ในการเข้ารหัส Huffmanซึ่งใช้เป็นรหัสการบีบอัด
• แผนผังทวิภาคใช้ในแผนผังการค้นหาแบบไบนารี่ซึ่งมีประโยชน์สำหรับการเก็บรักษาบันทึกข้อมูลโดยไม่มีพื้นที่ว่างมาก

ตัวอย่างหนึ่งที่น่าสนใจของต้นไม้ไบนารีที่ไม่ได้กล่าวถึงคือการแสดงออกทางคณิตศาสตร์ที่ประเมินซ้ำ โดยทั่วไปแล้วมันไร้ประโยชน์จากมุมมองที่ใช้งานได้จริง แต่มันเป็นวิธีที่น่าสนใจในการคิดถึงการแสดงออก

โดยทั่วไปแต่ละโหนดของทรีมีค่าที่มีอยู่ในตัวเองหรือถูกประเมินโดยการเรียกซ้ำโดยการดำเนินการกับค่าของลูก

ตัวอย่างเช่นนิพจน์(1+3)*2สามารถแสดงเป็น:

    *
   / \
  +   2
 / \
1   3

เพื่อประเมินการแสดงออกเราขอค่าของผู้ปกครอง โหนดนี้จะได้รับค่าจากลูกของมันตัวดำเนินการบวกและโหนดที่มี '2' อยู่ ตัวดำเนินการบวกจะได้รับค่าจากเด็ก ๆ ที่มีค่า '1' และ '3' และเพิ่มพวกเขากลับ 4 ไปยังโหนดการคูณซึ่งกลับ 8

การใช้ต้นไม้ไบนารีนี้คล้ายกับการขัดกลับสัญกรณ์ขัดในแง่ที่ว่าการดำเนินการจะดำเนินการเหมือนกัน อีกสิ่งหนึ่งที่ควรทราบคือมันไม่จำเป็นต้องเป็นต้นไม้ไบนารีมันเป็นเพียงว่าผู้ประกอบการที่ใช้กันมากที่สุดเป็นไบนารี ในระดับพื้นฐานที่สุดต้นไม้ไบนารีที่นี่ในความเป็นจริงเป็นเพียงภาษาการเขียนโปรแกรมการทำงานง่ายมาก

การใช้งานของต้นไม้ไบนารี:

1. การใช้เส้นทางตารางในเราเตอร์
2. รหัสการบีบอัดข้อมูล
3. การใช้งานตัวแยกวิเคราะห์นิพจน์และตัวแก้นิพจน์
4. เพื่อแก้ปัญหาฐานข้อมูลเช่นการจัดทำดัชนี
5. การประเมินผลการแสดงออก

ฉันไม่คิดว่าจะมีประโยชน์ใด ๆ สำหรับต้นไม้ไบนารี "บริสุทธิ์" (ยกเว้นเพื่อการศึกษา) ปรับสมดุลต้นไม้ไบนารีเช่นต้นไม้แดงดำหรือต้นไม้ AVLมีประโยชน์มากกว่าเพราะรับประกันการใช้งาน O (logn) ต้นไม้ไบนารีปกติอาจจบลงด้วยการเป็นรายการ (หรือเกือบจะเป็นรายการ) และไม่มีประโยชน์จริง ๆ ในแอปพลิเคชันที่ใช้ข้อมูลมาก

ต้นไม้ที่มีความสมดุลมักจะใช้สำหรับการทำแผนที่หรือชุด พวกเขายังสามารถใช้สำหรับการเรียงลำดับใน O (nlogn) แม้จะมีวิธีที่ดีกว่าที่จะทำ

นอกจากนี้สำหรับการค้นหา / แทรก / ลบตารางแฮชสามารถใช้ซึ่งมักจะมีประสิทธิภาพที่ดีกว่าแผนภูมิการค้นหาแบบไบนารี (สมดุลหรือไม่)

แอปพลิเคชันที่ต้นไม้การค้นหาแบบทวิภาค (สมดุล) จะมีประโยชน์จะเป็นถ้าการค้นหา / การแทรก / การลบและการเรียงลำดับจะต้องใช้ เรียงได้ในสถานที่ (เกือบละเว้นพื้นที่สแต็คที่จำเป็นสำหรับการสอบถามซ้ำ) ให้ต้นไม้สร้างสมดุลพร้อม มันจะยังคงเป็น O (nlogn) แต่มีปัจจัยคงที่ที่มีขนาดเล็กลงและไม่จำเป็นต้องใช้พื้นที่เพิ่มเติม (ยกเว้นสำหรับอาร์เรย์ใหม่โดยสมมติว่าข้อมูลจะต้องใส่ในอาร์เรย์) ตารางแฮชไม่สามารถจัดเรียงได้ (อย่างน้อยไม่ตรง)

บางทีพวกมันอาจมีประโยชน์ในอัลกอริทึมที่ซับซ้อนบางอย่างสำหรับการทำบางอย่าง แต่ไม่มีอะไรมาอยู่ในใจของฉัน หากฉันพบมากฉันจะแก้ไขโพสต์ของฉัน

ต้นไม้อื่น ๆ เช่นต้นไม้B + Bนั้นถูกใช้อย่างกว้างขวางในฐานข้อมูล

แอปพลิเคชั่นที่ใช้กันมากที่สุดอย่างหนึ่งคือการจัดเก็บข้อมูลอย่างมีประสิทธิภาพในรูปแบบที่เรียงเพื่อเข้าถึงและค้นหาองค์ประกอบที่เก็บไว้อย่างรวดเร็ว ตัวอย่างเช่นstd::mapหรือstd::setใน C ++ Standard Library

ต้นไม้ไบนารีเป็นโครงสร้างข้อมูลมีประโยชน์สำหรับการใช้งานตัวแยกวิเคราะห์นิพจน์และตัวแก้นิพจน์ต่าง ๆ

นอกจากนี้ยังอาจใช้ในการแก้ปัญหาฐานข้อมูลตัวอย่างเช่นการจัดทำดัชนี

โดยทั่วไปต้นไม้ไบนารีเป็นแนวคิดทั่วไปของโครงสร้างข้อมูลแบบต้นไม้และต้นไม้ไบนารีชนิดต่าง ๆ สามารถสร้างด้วยคุณสมบัติที่แตกต่างกัน

ใน C ++ STL และไลบรารี่มาตรฐานอื่น ๆ ในภาษาอื่นเช่น Java และ C # แผนผังการค้นหาแบบไบนารีถูกใช้เพื่อสร้างชุดและแผนที่

แอปพลิเคชั่นที่สำคัญที่สุดอย่างหนึ่งของต้นไม้ไบนารีคือต้นไม้ค้นหาแบบไบนารีที่สมดุลเช่น:

• ต้นไม้สีแดง - ดำ
• ต้นไม้ AVL
• ต้นแพะรับบาป

ต้นไม้ชนิดนี้มีคุณสมบัติที่ความแตกต่างของความสูงของทรีย่อยซ้ายและทรีย่อยด้านขวานั้นมีขนาดเล็กโดยทำการดำเนินการเช่นการหมุนในแต่ละครั้งที่มีการแทรกหรือลบโหนด

ด้วยเหตุนี้ความสูงโดยรวมของทรีจึงยังคงอยู่ในลำดับของ log n และการดำเนินการเช่นการค้นหาการแทรกและการลบโหนดจะดำเนินการในเวลา O (log n) STL ของ C ++ ยังใช้ต้นไม้เหล่านี้ในรูปแบบของชุดและแผนที่

สามารถใช้เป็นวิธีเรียงลำดับข้อมูลได้อย่างรวดเร็ว แทรกข้อมูลลงในแผนผังการค้นหาแบบไบนารีที่ O (log (n)) จากนั้นสำรวจต้นไม้เพื่อจัดเรียง

ไวยากรณ์โปรแกรมของคุณหรือสำหรับเรื่องอื่น ๆ อีกมากมายเช่นภาษาธรรมชาติสามารถแยกวิเคราะห์ได้โดยใช้ binary tree (แม้ว่าจะไม่จำเป็น)

การใช้งานของ java.util.Set

บนฮาร์ดแวร์ที่ทันสมัยต้นไม้ไบนารีเกือบจะไม่ดีนักเนื่องจากแคชที่ไม่ดีและพฤติกรรมของพื้นที่ สิ่งนี้ไปสำหรับตัวแปรย่อย (กึ่ง) หากคุณพบว่ามันเป็นสิ่งที่ประสิทธิภาพจะไม่นับ (หรือถูกครอบงำโดยฟังก์ชั่นเปรียบเทียบ) หรือมีแนวโน้มมากขึ้นด้วยเหตุผลทางประวัติศาสตร์หรือความไม่รู้

คอมไพเลอร์ที่ใช้ต้นไม้ไบนารีสำหรับการเป็นตัวแทนของ AST สามารถใช้อัลกอริทึมที่รู้จักสำหรับการแยกวิเคราะห์ต้นไม้เช่น postorder, inorder โปรแกรมเมอร์ไม่จำเป็นต้องคิดอัลกอริทึมของตัวเอง เนื่องจากต้นไม้ไบนารีสำหรับไฟล์ต้นฉบับสูงกว่าต้นไม้ n-ary การสร้างจึงใช้เวลามากกว่า รับการผลิตนี้: selstmnt: = "if" "(" expr ")" stmnt "ELSE" stmnt ในต้นไม้ไบนารีมันจะมี 3 ระดับของโหนด แต่ต้นไม้ n-ary จะมี 1 ระดับ (ของ chids)

นั่นเป็นสาเหตุที่ระบบปฏิบัติการ Unix ทำงานช้า