คุณต้องการแนะนำต้นไม้ไบนารีที่ปรับสมดุลตัวเองแบบใด

ฉันเรียนรู้ Haskell และออกกำลังกายฉันกำลังสร้างต้นไม้ไบนารี ต้องสร้างต้นไม้ไบนารีขึ้นมาเป็นประจำฉันต้องการที่จะปรับมันให้สมดุลกัน ดังนั้น:

• ข้อใดมีประสิทธิภาพมากที่สุด
• สิ่งที่ง่ายที่สุดที่จะใช้?
• ใช้บ่อยที่สุด?

แต่อะไรที่คุณแนะนำ?

ฉันคิดว่าสิ่งนี้เป็นของที่นี่เพราะเปิดให้มีการอภิปราย

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

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

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

ฉันจะพิจารณาทางเลือกถ้าคุณเป็นดีกับสุ่มโครงสร้างข้อมูล: รายการข้าม

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

คุณจะได้รับการแทรก / การค้นหา / ลบ O (บันทึก N) และคุณจะไม่ต้องจัดการกับกรณีที่ต้องทำการปรับสมดุลใหม่ทั้งหมด

ฉันไม่เคยคิดที่จะนำไปใช้ในภาษาที่ใช้งานได้และหน้าวิกิพีเดียไม่แสดงผลใด ๆ ดังนั้นจึงอาจไม่ใช่เรื่องง่าย (wrt to immutability)

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

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

EDIT ลบ "ภายในค่าคีย์" ด้านบน - การเรียงลำดับความสำคัญและการเรียงลำดับคีย์ใช้ร่วมกันดังนั้นลำดับความสำคัญจึงมีความสำคัญแม้กับคีย์ที่ไม่ซ้ำกัน

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

ข้อใดมีประสิทธิภาพมากที่สุด

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

หากคุณหมายถึง "เวลาทำงาน" หรือ "การใช้หน่วยความจำ" คุณจะต้องเปรียบเทียบการใช้งานจริง จากนั้นภาษาเวลาทำงานระบบปฏิบัติการและปัจจัยอื่น ๆ เข้ามาทำให้คำถามยากที่จะตอบ

สิ่งที่ง่ายที่สุดที่จะใช้?

คลุมเครือและตอบยาก อัลกอริทึมบางอย่างอาจซับซ้อนสำหรับคุณ แต่ไม่สำคัญกับฉัน

ใช้บ่อยที่สุด?

คลุมเครือและตอบยาก ครั้งแรกมี "โดยใคร?" ส่วนนี้ Haskell เท่านั้น? แล้ว C หรือ C ++ ล่ะ ข้อสองมีปัญหาซอฟต์แวร์ลิขสิทธิ์ที่เราไม่สามารถเข้าถึงแหล่งข้อมูลเพื่อทำแบบสำรวจ

แต่อะไรที่คุณแนะนำ?

ฉันคิดว่าสิ่งนี้เป็นของที่นี่เพราะเปิดให้มีการอภิปราย

แก้ไข. เนื่องจากเกณฑ์อื่น ๆ ของคุณไม่ค่อยมีประโยชน์นี่คือทั้งหมดที่คุณจะได้รับ

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

นี่คือรายการ:

http://en.wikipedia.org/wiki/Self-balancing_binary_search_tree

มีการกำหนดยอดนิยมหกรายการ เริ่มต้นด้วยสิ่งเหล่านั้น

หากคุณสนใจต้นไม้ Splay มีเวอร์ชั่นที่ง่ายกว่าซึ่งฉันเชื่อว่าเป็นครั้งแรกที่อธิบายไว้ในกระดาษโดย Allen และ Munroe มันไม่ได้รับประกันประสิทธิภาพการทำงานเหมือนกัน แต่หลีกเลี่ยงภาวะแทรกซ้อนในการจัดการกับการปรับสมดุล "zig-zig" กับ "zig-zag"

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

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

สิ่งหนึ่ง - เนื่องจากโครงสร้างข้อมูลตามคำจำกัดความเปลี่ยนแปลงแม้กระทั่งสำหรับการดำเนินการค้นหามันอาจจะต้องมีการดำเนินการ monadically IOW มันอาจจะไม่เหมาะสำหรับการเขียนโปรแกรมฟังก์ชั่น

ต้นไม้สมดุลง่ายมากเป็นต้นไม้ AA มันคงที่ง่ายกว่าและใช้ง่ายกว่า เนื่องจากความเรียบง่ายประสิทธิภาพจึงยังดี

ในการฝึกขั้นสูงคุณสามารถลองใช้GADTเพื่อใช้หนึ่งในสายพันธุ์ของทรีที่สมดุลซึ่งค่าคงที่นั้นถูกบังคับใช้โดยชนิดของระบบ