เหตุใด C ++ STL จึงไม่ให้บริการคอนเทนเนอร์ "ต้นไม้"

เหตุใด C ++ STL จึงไม่ให้บริการคอนเทนเนอร์ "ต้นไม้" และสิ่งที่ดีที่สุดที่จะใช้แทนคืออะไร

ฉันต้องการจัดเก็บลำดับชั้นของวัตถุเป็นต้นไม้แทนที่จะใช้ต้นไม้เป็นการปรับปรุงประสิทธิภาพ ...

มีสองเหตุผลที่คุณอาจต้องการใช้ทรี:

คุณต้องการสะท้อนปัญหาโดยใช้โครงสร้างแบบต้นไม้:
สำหรับเรื่องนี้เรามีห้องสมุดกราฟเพิ่ม

หรือคุณต้องการภาชนะที่มีต้นไม้เหมือนลักษณะการเข้าถึงสำหรับสิ่งนี้เรามี

• std::map(และstd::multimap)
• std::set(และstd::multiset)

โดยทั่วไปลักษณะของภาชนะทั้งสองนี้เป็นสิ่งที่พวกเขาต้องนำไปใช้จริงโดยใช้ต้นไม้ (แม้ว่านี่จะไม่ใช่ข้อกำหนด)

ดูคำถามนี้ด้วย: การใช้ C tree

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

บางประเด็นที่ต้องพิจารณา:

• จำนวนลูกของโหนดคงที่หรือเปลี่ยนแปลงหรือไม่?
• ค่าใช้จ่ายต่อโหนดเท่าไหร่ - เช่นคุณต้องการพอยน์เตอร์หลักพอยน์เตอร์พอยน์เตอร์เป็นต้น
• ขั้นตอนวิธีใดที่จะให้ - ตัววนซ้ำที่แตกต่างกันอัลกอริทึมการค้นหา ฯลฯ

ในท้ายที่สุดปัญหาก็คือภาชนะต้นไม้ที่จะมีประโยชน์มากพอสำหรับทุกคนจะหนักเกินไปที่จะทำให้คนส่วนใหญ่ใช้งาน หากคุณกำลังมองหาบางสิ่งที่ทรงพลังBoost Graph Libraryเป็นสิ่งที่สำคัญอย่างยิ่งในสิ่งที่สามารถใช้ไลบรารีต้นไม้ได้

นี่คือการใช้งานทรีทั่วไปอื่น ๆ :

• ต้นไม้ของ Kasper Peeters.hh
• ป่าของ Adobe
• หลัก :: ต้นไม้

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

"ฉันต้องการเก็บลำดับชั้นของวัตถุเป็นต้นไม้"

C ++ 11 มาถึงแล้วและพวกเขาก็ยังไม่เห็นความต้องการที่จะให้std::treeแม้ว่าความคิดจะเกิดขึ้นก็ตาม (ดูที่นี่ ) บางทีเหตุผลที่พวกเขาไม่ได้เพิ่มสิ่งนี้อาจเป็นเรื่องง่ายที่จะสร้างของคุณเองบนบรรจุภัณฑ์ที่มีอยู่แล้ว ตัวอย่างเช่น...

template< typename T >
struct tree_node
   {
   T t;
   std::vector<tree_node> children;
   };

การสำรวจเส้นทางอย่างง่ายจะใช้การเรียกซ้ำ ...

template< typename T >
void tree_node<T>::walk_depth_first() const
   {
   cout<<t;
   for ( auto & n: children ) n.walk_depth_first();
   }

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

หากคุณกำลังมองหาการนำ RB-tree มาใช้stl_tree.hก็อาจเหมาะสมสำหรับคุณเช่นกัน

มาตรฐาน :: แผนที่จะขึ้นอยู่กับต้นไม้สีดำสีแดง คุณยังสามารถใช้คอนเทนเนอร์อื่น ๆเพื่อช่วยคุณปรับใช้ต้นไม้ประเภทของคุณเอง

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

โดยทั่วไปถ้ามีการทำงานห้องสมุดพื้นฐานที่คุณต้องการที่ไม่ได้อยู่ใน STL การแก้ไขคือการดูที่BOOST

มิฉะนั้นมีพวงของห้องสมุด ออก มีขึ้นอยู่กับความต้องการของต้นไม้ของคุณ

คอนเทนเนอร์ STL ทั้งหมดถูกแสดงภายนอกเป็น "ลำดับ" พร้อมกับกลไกการวนซ้ำหนึ่งรายการ ต้นไม้ไม่ทำตามสำนวนนี้

เนื่องจาก STL ไม่ใช่ไลบรารี "ทุกอย่าง" มันมีโครงสร้างขั้นต่ำที่จำเป็นในการสร้างสิ่งต่าง ๆ

อันนี้ดูมีแนวโน้มและดูเหมือนจะเป็นสิ่งที่คุณกำลังมองหา: http://tree.phi-sci.com/

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

ตัวอย่างเช่น:

template <typename T>
struct TreeNode
{
  T* DATA ; // data of type T to be stored at this TreeNode

  vector< TreeNode<T>* > children ;

  // insertion logic for if an insert is asked of me.
  // may append to children, or may pass off to one of the child nodes
  void insert( T* newData ) ;

} ;

template <typename T>
struct Tree
{
  TreeNode<T>* root;

  // TREE LEVEL functions
  void clear() { delete root ; root=0; }

  void insert( T* data ) { if(root)root->insert(data); } 
} ;

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

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

template<class A>
struct unordered_tree : std::set<unordered_tree>, A
{};

template<class A>
struct b_tree : std::vector<b_tree>, A
{};

template<class A>
struct planar_tree : std::list<planar_tree>, A
{};

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

ต้นไม้มีบทบาทสำคัญในโครงสร้างทางคณิตศาสตร์จำนวนมาก (ดูเอกสารคลาสสิกของ Butcher, Grossman และ Larsen; นอกจากนี้เอกสารของ Connes และ Kriemer สำหรับตัวอย่างของพวกเขาสามารถเข้าร่วมและวิธีที่พวกเขาจะใช้ในการแจกแจง) มันไม่ถูกต้องที่จะคิดว่าบทบาทของพวกเขาเป็นเพียงเพื่ออำนวยความสะดวกในการดำเนินงานอื่น ๆ ค่อนข้างพวกเขาอำนวยความสะดวกในงานเหล่านั้นเพราะบทบาทพื้นฐานของพวกเขาเป็นโครงสร้างข้อมูล

อย่างไรก็ตามนอกเหนือจากต้นไม้แล้วยังมี "ต้นไม้ร่วม" ด้วย; ต้นไม้ด้านบนทั้งหมดมีคุณสมบัติที่ถ้าคุณลบรูทคุณจะลบทุกอย่าง

พิจารณาตัววนซ้ำบนต้นไม้บางทีพวกมันอาจถูกรู้ตัวว่าเป็นตัววนซ้ำอย่างง่าย ๆ ไปยังโหนดและกับผู้ปกครอง ... จนถึงราก

template<class TREE>
struct node_iterator : std::stack<TREE::iterator>{
operator*() {return *back();}
...};

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

ต้นไม้มีประโยชน์อย่างไม่น่าเชื่อพวกมันมีโครงสร้างมากมายทำให้มันเป็นความท้าทายที่สำคัญในการหาวิธีที่ถูกต้องอย่างแน่นอน ในมุมมองของฉันนี่คือเหตุผลที่พวกเขาไม่ได้ดำเนินการใน STL ยิ่งไปกว่านั้นในอดีตฉันเคยเห็นผู้คนเคร่งศาสนาและค้นหาแนวคิดของภาชนะบรรจุที่บรรจุอินสแตนซ์ที่ท้าทายประเภทของตัวเอง - แต่พวกเขาต้องเผชิญกับมัน - นั่นคือสิ่งที่ประเภทต้นไม้แสดงถึง - เป็นโหนดที่บรรจุ อาจเป็นที่เก็บว่างเปล่าของต้นไม้ (เล็กกว่า) ภาษาปัจจุบันอนุญาตให้ใช้โดยไม่ต้องมีการกำหนดค่าเริ่มต้นสำหรับการcontainer<B>จัดสรรพื้นที่บนฮีป (หรือที่อื่น) สำหรับการสร้างBเป็นต้น

ฉันสำหรับหนึ่งจะยินดีถ้าสิ่งนี้ในรูปแบบที่ดีหาทางลงในมาตรฐาน

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

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

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

คุณลักษณะที่สำคัญอื่น ๆ ที่ทรีต้องมีคือตัววนซ้ำแบบสำรวจภายใน

นี่คือสิ่งที่ฉันสามารถมากับ: https://github.com/igagis/utki/blob/master/src/utki/tree.hpp

และนี่คือการทดสอบ: https://github.com/igagis/utki/blob/master/tests/tree/tests.cpp

คอนเทนเนอร์ STL ทั้งหมดสามารถใช้กับตัววนซ้ำได้ คุณไม่สามารถมีตัววนซ้ำต้นไม้เนื่องจากคุณไม่มีวิธี '' ถูกต้อง '' ผ่านต้นไม้