สามวิธีในการจัดเก็บกราฟในหน่วยความจำข้อดีและข้อเสีย

มีสามวิธีในการจัดเก็บกราฟในหน่วยความจำ:

1. โหนดเป็นวัตถุและขอบเป็นตัวชี้
2. เมทริกซ์ที่มีน้ำหนักขอบทั้งหมดระหว่างโหนดที่มีหมายเลข x และโหนด y
3. รายการขอบระหว่างโหนดที่มีหมายเลข

ฉันรู้วิธีเขียนทั้งสามข้อ แต่ฉันไม่แน่ใจว่าฉันได้คิดถึงข้อดีและข้อเสียทั้งหมดของแต่ละข้อ

ข้อดีและข้อเสียของแต่ละวิธีในการจัดเก็บกราฟในหน่วยความจำคืออะไร?

วิธีหนึ่งในการวิเคราะห์สิ่งเหล่านี้คือในแง่ของความจำและความซับซ้อนของเวลา (ซึ่งขึ้นอยู่กับว่าคุณต้องการเข้าถึงกราฟอย่างไร)

การจัดเก็บโหนดเป็นอ็อบเจ็กต์โดยมีตัวชี้ซึ่งกันและกัน

• ความซับซ้อนของหน่วยความจำสำหรับแนวทางนี้คือ O (n) เนื่องจากคุณมีวัตถุมากเท่าที่คุณมีโหนด จำนวนพอยน์เตอร์ (ไปยังโหนด) ที่ต้องการขึ้นอยู่กับ O (n ^ 2) เนื่องจากแต่ละอ็อบเจ็กต์โหนดอาจมีพอยน์เตอร์สำหรับโหนดมากถึงโหนด
• ความซับซ้อนของเวลาสำหรับโครงสร้างข้อมูลนี้คือ O (n) สำหรับการเข้าถึงโหนดที่กำหนด

การจัดเก็บเมทริกซ์ของน้ำหนักขอบ

• นี่จะเป็นความซับซ้อนของหน่วยความจำของ O (n ^ 2) สำหรับเมทริกซ์
• ข้อดีของโครงสร้างข้อมูลนี้คือความซับซ้อนของเวลาในการเข้าถึงโหนดใด ๆ ที่กำหนดคือ O (1)

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

อีกสองสิ่งที่ควรพิจารณา:

1. แบบจำลองเมทริกซ์ช่วยให้กราฟที่มีขอบถ่วงน้ำหนักง่ายขึ้นโดยการจัดเก็บน้ำหนักไว้ในเมทริกซ์ โมเดลวัตถุ / ตัวชี้จะต้องจัดเก็บน้ำหนักขอบในอาร์เรย์คู่ขนานซึ่งต้องมีการซิงโครไนซ์กับอาร์เรย์ตัวชี้

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

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

โดยส่วนตัวแล้วฉันชอบเมทริกซ์ผู้ช่วยเพราะมันทำให้ปัญหาทุกประเภทง่ายขึ้นมากโดยใช้เครื่องมือจากทฤษฎีกราฟพีชคณิต (กำลัง kth ของเมทริกซ์ adjacency ให้จำนวนพา ธ ของความยาว k จากจุดยอด i ถึงจุดยอด j เช่นเพิ่มเมทริกซ์เอกลักษณ์ก่อนนำกำลัง kth เพื่อให้ได้จำนวนพา ธ ของความยาว <= k นำอันดับ n-1 รองของ Laplacian เพื่อรับจำนวนต้นไม้ที่ทอด ... และอื่น ๆ )

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

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

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

ความซับซ้อนของปริภูมิสำหรับวิธีเมทริกซ์จะเป็นไปตามแนวของ O (n ^ 2) (สมมติว่าขอบเป็นแบบทิศทางเดียว) หากกราฟของคุณเบาบางคุณจะมีเซลล์ว่างจำนวนมากในเมทริกซ์ของคุณ แต่ถ้ากราฟของคุณเชื่อมต่อกันอย่างสมบูรณ์ (e = n ^ 2) สิ่งนี้จะเปรียบเทียบได้ดีกับแนวทางแรก ตามที่ RG กล่าวไว้คุณอาจพลาดแคชน้อยลงด้วยวิธีนี้หากคุณจัดสรรเมทริกซ์เป็นหน่วยความจำชิ้นเดียวซึ่งอาจทำให้การติดตามขอบรอบ ๆ กราฟเร็วขึ้น

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

ดูตารางเปรียบเทียบบน wikipedia ช่วยให้เข้าใจได้ดีว่าเมื่อใดควรใช้การแสดงกราฟแต่ละรายการ

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

struct Node {
    ... node payload ...
    Edge *first_in;    // All incoming edges
    Edge *first_out;   // All outgoing edges
};

struct Edge {
    ... edge payload ...
    Node *from, *to;
    Edge *prev_in_from, *next_in_from; // dlist of same "from"
    Edge *prev_in_to, *next_in_to;     // dlist of same "to"
};

ค่าใช้จ่ายของหน่วยความจำมีขนาดใหญ่ (2 พอยน์เตอร์ต่อโหนดและ 6 พอยน์เตอร์ต่อขอบ) แต่คุณจะได้รับ

• การแทรกโหนด O (1)
• การแทรกขอบ O (1) (ให้ตัวชี้ไปที่โหนด "จาก" และ "ถึง")
• O (1) การลบขอบ (กำหนดตัวชี้)
• การลบโหนด O (deg (n)) (กำหนดตัวชี้)
• O (deg (n)) ค้นหาเพื่อนบ้านของโหนด

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

คำอธิบายรายละเอียดของวิธีการนี้สามารถใช้ได้ที่นี่

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

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

รายการ adjacency - เป็นเพียงรายการของโหนดที่เชื่อมต่อ - ดูเหมือนว่าหน่วยความจำจะมีประสิทธิภาพมากที่สุด แต่ก็อาจจะช้าที่สุดด้วย

การย้อนกลับกราฟกำกับทำได้ง่ายด้วยการแสดงเมทริกซ์และทำได้ง่ายด้วยรายการ adjacency แต่ไม่ค่อยดีนักกับการแสดงวัตถุ / ตัวชี้