โครงสร้างข้อมูล“ ล่วงล้ำ” หมายความว่าอย่างไร

ฉันเคยเห็นคำว่าล่วงล้ำใช้เพื่ออธิบายโครงสร้างข้อมูลเช่นรายการและสแต็ก แต่มันหมายความว่าอย่างไร

คุณสามารถยกตัวอย่างรหัสของโครงสร้างข้อมูลที่ล่วงล้ำได้และแตกต่างจากโครงสร้างที่ไม่ล่วงล้ำอย่างไร

นอกจากนี้เหตุใดจึงทำให้เป็นการล่วงล้ำ (หรือไม่ล่วงล้ำ) มีประโยชน์อย่างไร? มีข้อเสียอย่างไร?

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

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

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

หรือคุณสามารถสร้างสิ่งที่ล่วงล้ำโดยที่การอ้างอิงถึงแผนผังย่อยเหล่านั้นฝังอยู่ในค่านั้นเอง

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

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

จะไม่มีการบอกรายการที่ไม่ล่วงล้ำและจะต้องค้นหาว่ามีอะไรเปลี่ยนแปลงและเปลี่ยนแปลงไปอย่างไรด้วยตัวของมันเอง

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

ไม่ล่วงล้ำ:

template<typename T>
class LinkedList
{
  struct ListItem
  {
    T Value;
    ListItem* Prev;
    ListItem* Next;
  };

  ListItem* FirstItem;
  ListItem* LastItem;

  [...]
  ListItem* append(T&& val)
  {
    LastItem = LastItem.Next = new ListItem{val, LastItem, nullptr};
  };
};

LinkedList<int> IntList;

ล่วงล้ำ:

template<typename T>
class LinkedList
{
  T* FirstItem;
  T* LastItem;

  [...]
  T* append(T&& val)
  {
    T* newValue = new T(val);
    newValue.Next = nullptr;
    newValue.Prev = LastItem;
    LastItem.Next = newValue;
    LastItem = newValue;
  };
};

struct IntListItem
{
  int Value;
  IntListItem* Prev;
  IntListItem* Next;
};

LinkedList<IntListItem> IntList;

โดยส่วนตัวแล้วฉันชอบการออกแบบที่ล่วงล้ำเพื่อความโปร่งใส