โครงสร้างการค้นหาแบบไบนารี - ฐานข้อมูลแบบมีโครงสร้างที่มีโหนด สองลิงก์ไปยังโหนดอื่นๆ ทางขวาและทางซ้าย โหนดเป็นอ็อบเจ็กต์ของคลาสที่มีข้อมูล และ NULL เป็นสัญญาณที่ทำเครื่องหมายจุดสิ้นสุดของทรี
มันมักจะถูกเรียกว่า BST ซึ่งมีคุณสมบัติพิเศษ: โหนดที่ใหญ่กว่ารูทจะอยู่ทางด้านขวาของมัน และโหนดที่เล็กกว่าทางด้านซ้าย
ทฤษฎีและคำศัพท์ทั่วไป
ในแผนผังการค้นหาแบบไบนารี แต่ละโหนด (ไม่รวมรูท) เชื่อมต่อกันด้วยขอบตรงจากโหนดหนึ่งไปยังอีกโหนดหนึ่ง ซึ่งเรียกว่าพาเรนต์ แต่ละคนสามารถเชื่อมต่อกับโหนดจำนวนหนึ่งเรียกว่าลูก โหนดที่ไม่มี "ลูก" เรียกว่า ใบไม้ (โหนดนอก) องค์ประกอบที่ไม่ใช่ใบเรียกว่าภายใน โหนดที่มีพาเรนต์เดียวกันคือพี่น้อง โหนดบนสุดเรียกว่ารูท ใน BST กำหนดองค์ประกอบให้กับแต่ละโหนด และตรวจสอบให้แน่ใจว่ามีคุณสมบัติพิเศษที่ตั้งไว้สำหรับพวกเขา
คำศัพท์เกี่ยวกับต้นไม้:
- ความลึกของโหนดคือจำนวนขอบที่กำหนดจากรูทถึงโหนด
- ความสูงของโหนดคือจำนวนขอบที่กำหนดจากโหนดจนถึงใบไม้ที่ลึกที่สุด
- ความสูงของต้นไม้ถูกกำหนดโดยความสูงของราก
- โครงสร้างการค้นหาแบบไบนารีเป็นการออกแบบพิเศษ โดยให้อัตราส่วนความสูงและจำนวนโหนดที่ดีที่สุด
- ความสูง h กับ N โหนดที่มากที่สุด O (บันทึก N).
คุณสามารถพิสูจน์สิ่งนี้ได้ง่ายๆ โดยการนับโหนดในแต่ละระดับ โดยเริ่มจากรูท โดยสมมติว่ามีจำนวนโหนดมากที่สุด: n=1 + 2 + 4 + … + 2 h-1 + 2 h=2 ชั่วโมง + 1 - 1 การแก้สมการนี้สำหรับ h ให้ h=O (log n)
ประโยชน์ของไม้:
- สะท้อนความสัมพันธ์เชิงโครงสร้างของข้อมูล
- ใช้แทนลำดับชั้น
- ติดตั้งและค้นหาอย่างมีประสิทธิภาพ
- ต้นไม้เป็นข้อมูลที่ยืดหยุ่นมาก ช่วยให้คุณย้ายต้นไม้ย่อยได้โดยไม่ต้องใช้ความพยายามมาก
วิธีค้นหา
โดยทั่วไป ในการพิจารณาว่าค่าอยู่ใน BST หรือไม่ ให้เริ่มทรีการค้นหาแบบไบนารีที่รูทของมัน และพิจารณาว่าตรงตามข้อกำหนดหรือไม่:
- อยู่ที่ราก;
- อยู่ในทรีย่อยด้านซ้ายของรูท;
- ในทรีย่อยด้านขวาของรูท
หากไม่มีการลงทะเบียนฐาน การค้นหาแบบเรียกซ้ำจะดำเนินการในทรีย่อยที่เกี่ยวข้อง มีสองตัวเลือกพื้นฐาน:
- ต้นไม้ว่างเปล่า - คืนค่าเท็จ
- ค่าอยู่ในรูทโหนด - คืนค่าจริง
ควรสังเกตว่าแผนผังการค้นหาแบบไบนารีที่มีสคีมาที่พัฒนาแล้วจะเริ่มค้นหาตามเส้นทางจากรูทไปยังใบไม้เสมอ ในกรณีที่เลวร้ายที่สุด มันจะไปตลอดทางดังนั้นเวลาที่เลวร้ายที่สุดจึงเป็นสัดส่วนกับความยาวของเส้นทางที่ยาวที่สุดจากรากถึงใบซึ่งเป็นความสูงของต้นไม้ โดยทั่วไป นี่คือเวลาที่คุณจำเป็นต้องรู้ว่าต้องใช้เวลานานเท่าใดในการค้นหาเป็นฟังก์ชันของจำนวนค่าที่จัดเก็บไว้ในทรี
กล่าวอีกนัยหนึ่ง มีความสัมพันธ์ระหว่างจำนวนโหนดใน BST กับความสูงของต้นไม้ ขึ้นอยู่กับ "รูปร่าง" ในกรณีที่เลวร้ายที่สุด โหนดมีลูกเพียงคนเดียว และทรีการค้นหาแบบไบนารีที่สมดุลนั้นเป็นรายการที่เชื่อมโยง ตัวอย่างเช่น:
50
/
10
15
30
/
20
ต้นไม้นี้มี 5 โหนดและความสูง=5 การค้นหาค่าในช่วง 16-19 และ 21-29 จะต้องใช้เส้นทางต่อไปนี้จากรูทไปยังใบไม้ (โหนดที่มีค่า 20) เช่น จะต้องใช้เวลาตามสัดส่วนของจำนวนโหนด อย่างดีที่สุด พวกเขาทั้งหมดมีลูก 2 คน และใบก็อยู่ที่ระดับความลึกเท่ากัน
ต้นไม้ค้นหาไบนารีนี้มี 7 โหนดและความสูง=3 โดยทั่วไป ต้นไม้แบบนี้ (ต้นไม้เต็ม) จะมีความสูงประมาณบันทึก 2 (N) โดยที่ N คือจำนวนโหนดในต้นไม้. ค่าของบันทึก 2 (N) คือจำนวนครั้ง (2) ที่ N สามารถหารได้ก่อนที่จะถึงศูนย์
Summarizing: เวลาที่แย่ที่สุดในการค้นหา BST คือ O (ความสูงของต้นไม้) ต้นไม้ "เชิงเส้น" ที่แย่ที่สุดคือ O(N) โดยที่ N คือจำนวนโหนดในทรี อย่างดีที่สุด ต้นไม้ที่ "สมบูรณ์" คือ O(log N).
แทรกไบนารี BST
สงสัยว่าควรอยู่ตรงไหนโหนดใหม่ตั้งอยู่ใน BST คุณต้องเข้าใจตรรกะ ต้องวางตำแหน่งที่ผู้ใช้พบ นอกจากนี้ คุณต้องจำกฎ:
- ไม่อนุญาตให้ทำซ้ำ การพยายามแทรกค่าที่ซ้ำกันจะทำให้เกิดข้อยกเว้น
- วิธีการแทรกแบบสาธารณะใช้วิธีการ "ตัวช่วย" แบบเรียกซ้ำของตัวช่วยเพื่อแทรกจริงๆ
- โหนดที่มีค่าใหม่จะถูกแทรกเป็นลีฟใน BST เสมอ
- วิธีการแทรกแบบสาธารณะคืนค่าเป็นโมฆะ แต่วิธีตัวช่วยส่งคืนโหนด BST ดำเนินการนี้เพื่อจัดการกับกรณีที่โหนดส่งผ่านเป็นโมฆะ
โดยทั่วไป วิธี Helper จะระบุว่าหากต้นไม้การค้นหาไบนารีดั้งเดิมว่างเปล่า ผลลัพธ์จะเป็นต้นไม้ที่มีโหนดเดียว มิฉะนั้น ผลลัพธ์จะเป็นตัวชี้ไปยังโหนดเดียวกันกับที่ส่งผ่านเป็นอาร์กิวเมนต์
การลบในอัลกอริทึมไบนารี
อย่างที่คุณคิด การลบองค์ประกอบเกี่ยวข้องกับการค้นหาโหนดที่มีค่าที่จะลบออก รหัสนี้มีหลายอย่าง:
- BST ใช้ตัวช่วย วิธีการลบที่โอเวอร์โหลด หากองค์ประกอบที่คุณกำลังมองหาไม่อยู่ในทรี ในที่สุดเมธอด helper จะถูกเรียกด้วย n==null นี่ไม่ถือเป็นข้อผิดพลาด ต้นไม้ก็ไม่เปลี่ยนแปลงในกรณีนี้ วิธีการลบตัวช่วยส่งคืนค่า - ตัวชี้ไปยังแผนผังที่อัปเดต
- เมื่อลีฟถูกลบ การลบออกจากทรีการค้นหาแบบไบนารีจะตั้งค่าตัวชี้ย่อยที่สอดคล้องกันของพาเรนต์เป็น null หรือรูทเป็น null หากตัวที่ถูกลบออกโหนดเป็นรูทและไม่มีลูก
- โปรดทราบว่าการเรียกการลบต้องเป็นหนึ่งในสิ่งต่อไปนี้: root=delete (root, key), n.setLeft (delete (n.getLeft (), key)), n.setRight (delete(n. getRight(), คีย์)). ดังนั้น ในทั้งสามกรณีจึงถูกต้องที่วิธีลบจะคืนค่าเป็น null
- เมื่อค้นหาโหนดที่มีค่าที่จะลบสำเร็จ มีสามตัวเลือก: โหนดที่จะลบเป็นลีฟ (ไม่มีลูก) โหนดที่จะลบมีลูกหนึ่งคน มีสองคน เด็ก.
- เมื่อโหนดที่ถูกลบมีลูกหนึ่งคน คุณสามารถแทนที่มันด้วยลูก แล้วส่งตัวชี้กลับไปที่เด็ก
- หากโหนดที่จะลบมีศูนย์หรือ 1 ลูก วิธีการลบจะ "ตามเส้นทาง" จากรากไปยังโหนดนั้น ดังนั้นเวลาที่แย่ที่สุดคือสัดส่วนกับความสูงของต้นไม้ ทั้งการค้นหาและแทรก
หากโหนดที่จะลบมีลูกสองคน ให้ทำตามขั้นตอนต่อไปนี้:
- ค้นหาโหนดที่จะลบ ตามเส้นทางจากรูทไปยังโหนดนั้น
- หาค่าที่น้อยที่สุดของ v ในทรีย่อยด้านขวา ไปตามเส้นทางไปยังใบไม้
- ลบค่าของ v ซ้ำๆ ตามเส้นทางเดียวกับในขั้นตอนที่ 2
- ดังนั้น ในกรณีที่เลวร้ายที่สุด เส้นทางจากรากถึงใบจะดำเนินการสองครั้ง
ลำดับการข้าม
การข้ามผ่านเป็นกระบวนการที่เข้าชมโหนดทั้งหมดในทรี เนื่องจากโครงสร้างการค้นหาแบบไบนารี C เป็นโครงสร้างข้อมูลที่ไม่เป็นเชิงเส้น จึงไม่มีการข้ามผ่านที่ไม่ซ้ำกัน ตัวอย่างเช่น บางครั้งอัลกอริธึมการข้ามผ่านหลายครั้งแบ่งออกเป็นสองประเภทต่อไปนี้:
- ข้ามความลึก;
- รอบแรก
มีการข้ามความกว้างเพียงประเภทเดียว - ข้ามระดับ การข้ามผ่านนี้ไปที่โหนดระดับล่างและซ้าย บนและขวา
การข้ามความลึกมีสามประเภท:
- ผ่านการสั่งซื้อล่วงหน้า - ไปพบผู้ปกครองก่อนแล้วจึงไปที่ลูกซ้ายและขวา
- ผ่าน InOrder - ไปเยี่ยมลูกทางซ้าย จากนั้นพ่อแม่และลูกขวา
- ผ่าน PostOrder - ไปเยี่ยมลูกทางซ้าย จากนั้นไปลูกทางขวา จากนั้นไปที่ผู้ปกครอง
ตัวอย่างสำหรับการข้ามสี่ครั้งของโครงสร้างการค้นหาแบบไบนารี:
- PreOrder - 8, 5, 9, 7, 1, 12, 2, 4, 11, 3.
- InOrder - 9, 5, 1, 7, 2, 12, 8, 4, 3, 11.
- PostOrder - 9, 1, 2, 12, 7, 5, 3, 11, 4, 8.
- LevelOrder - 8, 5, 4, 9, 7, 11, 1, 12, 3, 2.
รูปแสดงลำดับการเข้าเยี่ยมชมโหนด หมายเลข 1 คือโหนดแรกในการข้ามผ่านเฉพาะ และ 7 คือโหนดสุดท้าย
การข้ามผ่านทั่วไปเหล่านี้สามารถแสดงเป็นอัลกอริธึมเดียว สมมติว่าแต่ละโหนดมีการเข้าชมสามครั้ง ทัวร์ออยเลอร์เป็นการเดินรอบต้นไม้ไบนารีซึ่งแต่ละขอบจะถือว่าเป็นกำแพงที่ผู้ใช้ข้ามไม่ได้ ในการเดินครั้งนี้ แต่ละโหนดจะเข้าชมทางด้านซ้าย ด้านล่าง หรือด้านขวา ทัวร์ออยเลอร์ ซึ่งไปที่โหนดทางด้านซ้าย ทำให้เกิดการข้ามคำบุพบท เมื่อมีการเยี่ยมชมโหนดด้านล่าง โหนดจะถูกสำรวจตามลำดับ และเมื่อมีการเยี่ยมชมโหนดทางด้านขวา - getบายพาสทีละขั้นตอน
การนำทางและการดีบัก
เพื่อให้นำทางบนต้นไม้ได้ง่ายขึ้น ให้สร้างฟังก์ชันที่ตรวจสอบก่อนว่าเป็นคนซ้ายหรือขวา ในการเปลี่ยนตำแหน่งของโหนด จะต้องมีการเข้าถึงตัวชี้ที่โหนดหลักได้ง่าย การนำทรีไปใช้อย่างถูกต้องเป็นเรื่องยากมาก ดังนั้นคุณจำเป็นต้องรู้และใช้กระบวนการดีบัก ต้นไม้การค้นหาแบบไบนารีที่มีการนำไปใช้มักจะมีตัวชี้ที่ไม่ได้ระบุทิศทางของการเดินทางจริงๆ
ในการคิดทั้งหมดนี้ มีการใช้ฟังก์ชันที่ตรวจสอบว่าต้นไม้สามารถแก้ไขได้หรือไม่ และช่วยในการค้นหาข้อผิดพลาดมากมาย ตัวอย่างเช่น จะตรวจสอบว่าโหนดหลักเป็นโหนดย่อยหรือไม่ ด้วย assert(is_wellformed(root)) ข้อผิดพลาดจำนวนมากสามารถตรวจพบได้ก่อนกำหนด การใช้เบรกพอยต์ที่ให้มาสองสามจุดภายในฟังก์ชันนี้ คุณยังสามารถระบุได้ว่าตัวชี้ตัวใดผิด
ฟังก์ชั่น Konsolenausgabe
ฟังก์ชันนี้จะล้างทรีทั้งหมดไปที่คอนโซล ดังนั้นจึงมีประโยชน์มาก ลำดับที่เป้าหมายเอาต์พุตทรีคือ:
- ในการทำเช่นนี้ คุณต้องกำหนดก่อนว่าข้อมูลใดที่จะส่งออกผ่านโหนด
- และคุณต้องรู้ว่าต้นไม้กว้างและสูงแค่ไหนเพื่อใช้พื้นที่ที่เหลือ
- ฟังก์ชันต่อไปนี้จะคำนวณข้อมูลนี้สำหรับทรีและแต่ละทรีย่อย เนื่องจากคุณสามารถเขียนไปยังคอนโซลทีละบรรทัดเท่านั้น คุณจะต้องพิมพ์ต้นไม้ทีละบรรทัด
- ตอนนี้เราต้องถอนด้วยวิธีอื่นทั้งต้น ไม่ใช่แค่ต่อแถว
- ด้วยความช่วยเหลือของฟังก์ชันดัมพ์ คุณสามารถอ่านแผนผังและปรับปรุงอัลกอริธึมเอาต์พุตได้อย่างมาก ในแง่ของความเร็ว
อย่างไรก็ตาม ฟังก์ชันนี้จะใช้งานบนต้นไม้ใหญ่ได้ยาก
คัดลอกตัวสร้างและตัวทำลาย
เนื่องจากแผนผังไม่ใช่โครงสร้างข้อมูลที่ไม่ซับซ้อน จึงควรใช้ตัวสร้างการคัดลอก ตัวทำลาย และตัวดำเนินการมอบหมายงาน Destructor นั้นง่ายต่อการใช้งานแบบเรียกซ้ำ สำหรับต้นไม้ใหญ่มาก ก็สามารถรับมือ "กองน้ำล้น" ได้ ในกรณีนี้ จะเป็นการสร้างสูตรซ้ำๆ แนวความคิดคือการเอาใบที่แทนค่าที่น้อยที่สุดของใบทั้งหมดออก ให้อยู่ทางด้านซ้ายของต้นไม้ การตัดใบแรกออกจะสร้างใบใหม่ และต้นไม้ก็เล็กลงจนหมดสิ้น
ตัวสร้างการคัดลอกสามารถนำไปใช้ซ้ำได้ แต่ระวังหากมีข้อยกเว้น มิฉะนั้น ต้นไม้จะเกิดความสับสนและเกิดข้อผิดพลาดได้อย่างรวดเร็ว นั่นเป็นเหตุผลที่แนะนำให้ใช้เวอร์ชันวนซ้ำ แนวคิดคือการผ่านต้นไม้เก่าและต้นไม้ใหม่ เช่นเดียวกับที่คุณทำในตัวทำลาย โดยโคลนโหนดทั้งหมดที่อยู่ในต้นไม้เก่าแต่ไม่ใช่โหนดใหม่
ด้วยวิธีการนี้ การนำโครงสร้างการค้นหาแบบไบนารีไปใช้งานจะอยู่ในสถานะปกติเสมอ และตัวทำลายล้างสามารถลบออกได้แม้ในสถานะที่ไม่สมบูรณ์ หากเกิดข้อยกเว้น สิ่งที่คุณต้องทำคือสั่งให้ destructor ลบทรีกึ่งสำเร็จรูป ผู้ดำเนินการมอบหมายใช้งานได้ง่ายโดยใช้ Copy & Swap
การสร้างแผนผังการค้นหาแบบไบนารี
แผนผังการค้นหาไบนารีที่เหมาะสมที่สุดจะมีประสิทธิภาพอย่างเหลือเชื่อหากจัดการอย่างถูกต้อง กฎบางประการสำหรับทรีการค้นหาแบบไบนารี:
- โหนดหลักมีโหนดย่อยไม่เกิน 2 โหนด
- โหนดลูกด้านซ้ายจะน้อยกว่าโหนดหลักเสมอ
- โหนดลูกที่ถูกต้องจะมากกว่าหรือเท่ากับโหนดหลักเสมอ
อาร์เรย์ที่จะใช้ในการสร้างแผนผังการค้นหาแบบไบนารี:
- อาร์เรย์จำนวนเต็มพื้นฐานของเจ็ดค่าในลำดับที่ไม่เรียงลำดับ
- ค่าแรกในอาร์เรย์คือ 10 ดังนั้นขั้นตอนแรกในการสร้างทรีคือการสร้างโหนดราก 10 โหนด ดังที่แสดงไว้ที่นี่
- ด้วยชุดของโหนดรูท ค่าอื่นๆ ทั้งหมดจะเป็นลูกของโหนดนี้ อ้างอิงจากกฎ ขั้นตอนแรกที่จะเพิ่ม 7 ให้กับทรีคือการเปรียบเทียบกับโหนดรูท
- ถ้าค่า 7 น้อยกว่า 10 มันจะกลายเป็นโหนดลูกด้านซ้าย
- ถ้าค่า 7 มากกว่าหรือเท่ากับ 10 จะเลื่อนไปทางขวา เนื่องจาก 7 มีค่าน้อยกว่า 10 จึงถูกกำหนดให้เป็นโหนดย่อยด้านซ้าย
- ทำการเปรียบเทียบแต่ละองค์ประกอบซ้ำๆ
- ตามรูปแบบเดียวกัน ทำการเปรียบเทียบแบบเดียวกันกับค่าที่ 14 ในอาร์เรย์
- เปรียบเทียบค่า 14 กับโหนดรูท 10 โดยรู้ว่า 14 เป็นลูกที่ถูกต้อง
- เดินผ่านอาเรย์มาที่ 20.
- เริ่มโดยการเปรียบเทียบอาร์เรย์กับ 10 แล้วแต่จำนวนใดจะมากกว่า ดังนั้นย้ายไปทางขวาแล้วเปรียบเทียบกับ 14 เขาอายุมากกว่า 14 และไม่มีลูกทางด้านขวา
- ตอนนี้มีค่าเป็น 1 ตามรูปแบบเดียวกันกับค่าอื่นๆ เปรียบเทียบ 1 ถึง 10 ย้ายไปทางซ้ายและเปรียบเทียบกับ 7 และสุดท้ายไปยังลูกที่ 1 ซ้ายของโหนดที่ 7
- ถ้าค่าคือ 5 ให้เปรียบเทียบกับ 10 เนื่องจาก 5 มีค่าน้อยกว่า 10 ให้ส่งไปทางซ้ายแล้วเปรียบเทียบกับ 7
- รู้ว่า 5 มีค่าน้อยกว่า 7 ให้เดินต่อไปตามต้นไม้แล้วเปรียบเทียบ 5 กับ 1 ค่า
- ถ้า 1 ไม่มีลูกและ 5 มากกว่า 1 แล้ว 5 ลูกที่ถูกต้องของ 1 โหนด
- สุดท้ายใส่ค่า 8 เข้าไปในต้นไม้
- เมื่อ 8 น้อยกว่า 10 ให้เลื่อนไปทางซ้ายแล้วเปรียบเทียบกับ 7, 8 มากกว่า 7 ดังนั้นให้เลื่อนไปทางขวาและเติมต้นไม้ให้ครบ ทำให้ 8 ลูกเป็นลูก 7 คนที่เหมาะสม
รับและประเมินความสง่างามที่เรียบง่ายของแผนผังการค้นหาไบนารีที่เหมาะสมที่สุด เช่นเดียวกับหัวข้ออื่นๆ ในการเขียนโปรแกรม พลังของแผนผังการค้นหาแบบไบนารีมาจากความสามารถในการแก้ไขข้อมูลให้เป็นส่วนประกอบขนาดเล็กที่เกี่ยวข้อง จากนี้ไป คุณสามารถทำงานกับชุดข้อมูลทั้งหมดได้อย่างเป็นระเบียบ
ปัญหาการค้นหาไบนารีที่อาจเกิดขึ้น
ต้นไม้การค้นหาแบบไบนารีนั้นยอดเยี่ยม แต่มีข้อแม้บางประการที่ควรคำนึงถึง โดยปกติแล้วจะมีผลก็ต่อเมื่อมีความสมดุล ต้นไม้ที่สมดุลคือต้นไม้ที่ความแตกต่างระหว่างความสูงของทรีย่อยของโหนดใดๆ ในทรีมีค่าสูงสุดหนึ่งรายการ ลองดูตัวอย่างที่อาจช่วยชี้แจงกฎได้ ลองนึกภาพว่าอาร์เรย์เริ่มต้นเป็นแบบจัดเรียงได้
หากคุณพยายามเรียกใช้อัลกอริธึมทรีการค้นหาแบบไบนารีบนทรีนี้ มันจะดำเนินการเหมือนกับว่าเพิ่งวนซ้ำในอาร์เรย์จนกว่าจะพบค่าที่ต้องการ พลังของการค้นหาแบบไบนารีอยู่ที่ความสามารถในการกรองค่าที่ไม่ต้องการออกอย่างรวดเร็ว เมื่อต้นไม้ไม่สมดุล มันจะไม่ให้ประโยชน์เหมือนกับต้นไม้ที่สมดุล
การตรวจสอบข้อมูลที่ผู้ใช้กำลังทำงานด้วยเมื่อสร้างแผนผังการค้นหาแบบไบนารีเป็นสิ่งสำคัญมาก คุณสามารถผสานรวมกิจวัตร เช่น การสุ่มอาร์เรย์ก่อนที่จะใช้โครงสร้างการค้นหาแบบไบนารีสำหรับจำนวนเต็มเพื่อสร้างความสมดุล
ตัวอย่างการคำนวณการค้นหาไบนารี
เราจำเป็นต้องกำหนดว่าต้นไม้ชนิดใดจะเกิดผลหากใส่ 25 ลงในทรีค้นหาไบนารีต่อไปนี้:
10
/
/
5 15
/ /
/ /
2 12 20
เมื่อแทรก x ลงในต้นไม้ T ที่ยังไม่มี x คีย์ x จะถูกวางไว้ในใบไม้ใหม่เสมอ ต้นไม้ใหม่จะมีลักษณะดังนี้:
10
/
/
5 15
/ /
/ /
2 12 20
25
คุณจะได้ต้นไม้ชนิดใดถ้าคุณแทรก 7 ลงในโครงสร้างการค้นหาไบนารีต่อไปนี้
10
/
/
5 15
/ /
/ /
2 12 20
เฉลย:
10
/
/
/
5 15
/ / / \"
/ / / \"
2 7 12 20
ต้นไม้การค้นหาแบบไบนารีสามารถใช้เก็บวัตถุใดก็ได้ ข้อดีของการใช้โครงสร้างการค้นหาแบบไบนารีแทนการเชื่อมโยงรายการคือถ้าต้นไม้มีความสมดุลพอสมควรและเหมือนต้นไม้ที่ "เต็ม" มากกว่าต้นไม้ "เชิงเส้น" การแทรก การค้นหา และการดำเนินการลบทั้งหมดสามารถดำเนินการได้ เวลา O(log N)