โครงสร้างข้อมูล NET: ArrayList, List, HashTable, Dictionary, SortedList, SortedDictionary - ความเร็ว, หน่วยความจำและเมื่อใช้แต่ละอัน?

.NET มีโครงสร้างข้อมูลที่ซับซ้อนจำนวนมาก น่าเสียดายที่บางคนก็คล้ายกันและฉันก็ไม่แน่ใจเสมอว่าจะใช้เมื่อไรและเมื่อใช้อีกอัน หนังสือ C # และ Visual Basic ส่วนใหญ่พูดถึงพวกเขาในระดับหนึ่ง แต่พวกเขาไม่เคยไปลงลึกถึงรายละเอียดที่แท้จริง

ความแตกต่างระหว่าง Array, ArrayList, List, Hashtable, Dictionary, SortedList และ SortedDictionary คืออะไร

อันไหนที่นับได้ (IList - สามารถทำลูป 'foreach' ได้)? อันไหนที่ใช้คู่คีย์ / ค่า (IDict)

แล้วรอยเท้าหน่วยความจำล่ะ? ความเร็วในการแทรก? ความเร็วในการดึงข้อมูล?

มีโครงสร้างข้อมูลอื่น ๆ ที่น่ากล่าวถึงไหม?

ฉันยังคงค้นหารายละเอียดเพิ่มเติมเกี่ยวกับการใช้หน่วยความจำและความเร็ว (สัญลักษณ์ Big-O)

ปิดส่วนหัวของฉัน:

• Array* - หมายถึงอาร์เรย์หน่วยความจำแบบโรงเรียนเก่า - ชนิดคล้ายนามแฝงสำหรับtype[]อาร์เรย์ปกติ สามารถระบุ ไม่สามารถเติบโตได้โดยอัตโนมัติ ฉันจะถือว่าความเร็วในการแทรกและความเร็วในการกลับคืนมาเร็วมาก

• ArrayList- อาร์เรย์ที่กำลังเติบโตโดยอัตโนมัติ เพิ่มค่าใช้จ่ายเพิ่มเติม สามารถ enum. อาจช้ากว่าอาร์เรย์ปกติ แต่ก็ยังค่อนข้างเร็ว สิ่งเหล่านี้ถูกใช้บ่อยใน. NET

• List- หนึ่งใน favs ของฉัน - List<string>สามารถใช้ร่วมกับยาชื่อสามัญเพื่อให้คุณสามารถมีอาร์เรย์พิมพ์มั่นเช่น นอกเหนือจากนั้นก็ทำหน้าที่เป็นอย่างมากArrayList

• Hashtable- hashtable แบบเก่าธรรมดา O (1) ถึง O (n) กรณีที่แย่ที่สุด สามารถระบุคุณสมบัติค่าและคีย์และทำคู่คีย์ / val

• Dictionary - เหมือนข้างบนเท่านั้นพิมพ์โดยเฉพาะอย่างยิ่งผ่าน generics เช่น Dictionary<string, string>

• SortedList- รายการทั่วไปเรียงลำดับ ชะลอการแทรกเนื่องจากต้องคิดว่าจะใส่อะไรดี สามารถ enum. อาจเหมือนกันกับการดึงข้อมูลเนื่องจากไม่จำเป็นต้องใช้ แต่การลบจะช้ากว่ารายการเก่าแบบธรรมดา

ฉันมักจะใช้ListและDictionaryตลอดเวลา - เมื่อคุณเริ่มใช้พวกเขาพิมพ์อย่างยิ่งกับยาชื่อสามัญมันยากจริงๆที่จะกลับไปที่คนที่ไม่ใช่มาตรฐานทั่วไป

มีโครงสร้างข้อมูลอื่น ๆ อีกมากมายด้วยKeyValuePairซึ่งคุณสามารถใช้ทำสิ่งที่น่าสนใจบางอย่างSortedDictionaryซึ่งมีประโยชน์เช่นกัน

ถ้าเป็นไปได้ให้ใช้ยาสามัญ รวมถึง:

• รายการแทน ArrayList
• พจนานุกรมแทน HashTable

ก่อนอื่นคอลเลกชันทั้งหมดใน. NET จะใช้ IEnumerable

ประการที่สองคอลเลกชันจำนวนมากซ้ำกันเนื่องจากมีการเพิ่มชื่อสามัญในเวอร์ชัน 2.0 ของเฟรมเวิร์ก

ดังนั้นแม้ว่าคอลเลกชันทั่วไปน่าจะเพิ่มคุณสมบัติส่วนใหญ่:

• รายการเป็นการใช้งานทั่วไปของ ArrayList
• พจนานุกรมเป็นการใช้งานทั่วไปของ Hashtable

อาร์เรย์เป็นคอลเลกชันขนาดคงที่ที่คุณสามารถเปลี่ยนค่าที่เก็บไว้ในดัชนีที่กำหนด

SortedDictionary เป็น IDictionary ที่เรียงตามคีย์ SortedList เป็น IDictionary ที่เรียงลำดับตาม IComparer ที่ต้องการ

ดังนั้นการใช้งาน IDictionary (ผู้ที่สนับสนุน KeyValuePairs) คือ: * Hashtable * Dictionary * SortedList * SortedDictionary

คอลเลกชันอื่นที่ถูกเพิ่มเข้ามาใน. NET 3.5 คือ Hashset มันเป็นคอลเลกชันที่รองรับการตั้งค่า

นอกจากนี้ LinkedList ยังเป็นการนำมาตรฐานรายการที่มีการเชื่อมโยง (รายการนั้นเป็นรายการอาร์เรย์เพื่อการดึงข้อมูลที่เร็วขึ้น)

นี่คือเคล็ดลับทั่วไปบางประการสำหรับคุณ:

• คุณสามารถใช้กับประเภทที่ใช้foreach โดยพื้นฐานแล้วจะเป็นคุณสมบัติwith และ(การเข้าถึงรายการโดยใช้ดัชนี zero-based) ในทางกลับกันหมายความว่าคุณสามารถเข้าถึงรายการต่างๆได้โดยใช้ดัชนีใด ๆ ที่แฮชIEnumerableIListIEnumberableCountItemIDictionary

• Array, ArrayListและทั้งหมดใช้ List , และการดำเนินการIListDictionarySortedDictionaryHashtableIDictionary

• หากคุณกำลังใช้. NET 2.0 หรือสูงกว่าขอแนะนำให้คุณใช้คู่ทั่วไปประเภทที่กล่าวถึง

• สำหรับเวลาและพื้นที่ที่ซับซ้อนของการดำเนินการต่างๆในประเภทเหล่านี้คุณควรศึกษาเอกสารประกอบของพวกเขา

• โครงสร้างข้อมูล. NET อยู่ในSystem.Collectionsเนมสเปซ มีไลบรารีชนิดต่าง ๆ เช่นPowerCollectionsซึ่งเสนอโครงสร้างข้อมูลเพิ่มเติม

• ที่จะได้รับความเข้าใจในโครงสร้างข้อมูลที่ปรึกษาทรัพยากรเช่นCLRS

โครงสร้างข้อมูล NET:

บทสนทนาเพิ่มเติมเกี่ยวกับสาเหตุที่ ArrayList และ List แตกต่างกัน

อาร์เรย์

ในฐานะผู้ใช้รายหนึ่งอาร์เรย์คือคอลเล็กชัน "โรงเรียนเก่า" (ใช่อาร์เรย์ถือเป็นคอลเล็กชันแม้ว่าจะไม่ใช่ส่วนหนึ่งของSystem.Collections) แต่อะไรคือ "โรงเรียนเก่า" เกี่ยวกับอาร์เรย์เมื่อเปรียบเทียบกับคอลเลกชันอื่น ๆ นั่นคือสิ่งที่คุณได้ระบุไว้ในชื่อเรื่องของคุณ (ที่นี่ ArrayList และ List (Of T)) เริ่มต้นด้วยพื้นฐานโดยดูที่อาร์เรย์

ในการเริ่มต้นอาร์เรย์ใน Microsoft .NET คือ "กลไกที่อนุญาตให้คุณจัดการกับรายการ [ที่เกี่ยวข้องกับเหตุผลทางตรรกะ] หลายรายการเป็นคอลเล็กชันเดียว" (ดูบทความที่เชื่อมโยง) นั่นหมายความว่าอย่างไร? อาร์เรย์เก็บสมาชิกแต่ละคน (องค์ประกอบ) เรียงตามลำดับหนึ่งหลังในหน่วยความจำที่มีที่อยู่เริ่มต้น ด้วยการใช้อาร์เรย์เราสามารถเข้าถึงองค์ประกอบที่จัดเก็บตามลำดับโดยเริ่มต้นจากที่อยู่นั้น

นอกเหนือจากนั้นและตรงกันข้ามกับการเขียนโปรแกรมแนวความคิดทั่วไป 101 แล้วอาร์เรย์สามารถค่อนข้างซับซ้อน:

อาร์เรย์สามารถเป็นมิติข้อมูลเดียวหลายมิติหรือ jadded (อาร์เรย์แบบขรุขระมีมูลค่าการอ่าน) อาร์เรย์จะไม่ไดนามิก: เมื่อเริ่มต้นแล้วอาร์เรย์ของขนาดn จะสำรองพื้นที่เพียงพอที่จะเก็บวัตถุจำนวนn จำนวนองค์ประกอบในอาร์เรย์ไม่สามารถเพิ่มหรือลดขนาดได้ Dim _array As Int32() = New Int32(100)สงวนพื้นที่ว่างเพียงพอบนบล็อกหน่วยความจำสำหรับอาร์เรย์เพื่อให้มีวัตถุชนิดดั้งเดิม 100 Int32 (ในกรณีนี้อาร์เรย์จะถูกเตรียมใช้งานให้มี 0 วินาที) _arrayที่อยู่ของบล็อกนี้ถูกส่งกลับไป

ตามบทความข้อกำหนดทั่วไปของภาษา (CLS) ต้องการให้อาร์เรย์ทั้งหมดเป็นศูนย์ อาร์เรย์ใน. NET สนับสนุนอาร์เรย์ที่ไม่เป็นศูนย์ อย่างไรก็ตามนี่เป็นเรื่องธรรมดาน้อยกว่า อันเป็นผลมาจาก "Common-Ness" ของอาร์เรย์แบบ zero-based Microsoft ได้ใช้เวลาในการปรับประสิทธิภาพให้เหมาะสมที่สุด ดังนั้นมิติเดียวอาร์เรย์ zero-based (SZs) จึงเป็น "พิเศษ" - และเป็นการใช้งานที่ดีที่สุดของอาร์เรย์

อาร์เรย์จะถูกส่งผ่านโดยการอ้างอิงเสมอ (เป็นที่อยู่หน่วยความจำ) - ชิ้นส่วนสำคัญของตัวต่อ Array ที่ต้องรู้ ในขณะที่พวกเขาทำการตรวจสอบขอบเขต (จะโยนข้อผิดพลาด), การตรวจสอบขอบเขตสามารถปิดการใช้งานในอาร์เรย์

อีกครั้งอุปสรรคที่ใหญ่ที่สุดในอาร์เรย์คือพวกเขาไม่ได้ปรับขนาดได้อีกครั้ง พวกเขามีความจุ "คงที่" แนะนำ ArrayList และ List (Of T) กับประวัติของเรา:

ArrayList - รายการที่ไม่ใช่ทั่วไป

The ArrayList (พร้อมด้วยList(Of T)- แม้ว่าจะมีความแตกต่างที่สำคัญบางอย่างที่นี่อธิบายในภายหลัง) - อาจเป็นความคิดที่ดีที่สุดที่จะเป็นส่วนเสริมถัดไปของคอลเลกชัน (ในแง่กว้าง) ArrayList สืบทอดมาจากส่วนต่อประสานIList (ผู้สืบทอดของ 'ICollection') ArrayLists ตัวเองเป็นbulkier - กำหนดให้มากขึ้นค่าใช้จ่าย - กว่ารายการ

IListไม่เปิดใช้งานการใช้งานเพื่อปฏิบัติกับ ArrayLists เป็นรายการขนาดคงที่ (เช่นอาร์เรย์) อย่างไรก็ตามนอกเหนือจากฟังก์ชั่นเพิ่มเติมทั้งหมดที่เพิ่มโดย ArrayLists แล้วไม่มีข้อได้เปรียบที่แท้จริงในการใช้ ArrayLists ที่มีขนาดคงที่ในฐานะ ArrayLists (เหนืออาร์เรย์) ในกรณีนี้จะช้ากว่าอย่างเห็นได้ชัด

จากการอ่านของฉัน ArrayLists ไม่สามารถขรุขระได้: "การใช้อาร์เรย์หลายมิติเป็นองค์ประกอบ ... ไม่รองรับ" อีกครั้งหนึ่งตอกตะปูในโลงศพของ ArrayLists ArrayLists ยังไม่ได้ "พิมพ์" - หมายความว่าทุกอย่างอยู่ภายใต้การ ArrayList Object[]เป็นเพียงอาร์เรย์แบบไดนามิกของวัตถุที่: สิ่งนี้ต้องการการชกมวยจำนวนมาก (โดยนัย) และการยกเลิกการทำบ็อกซ์ (ชัดเจน) เมื่อใช้ ArrayLists และเพิ่มค่าใช้จ่ายอีกครั้ง

ความคิดที่ไม่พร้อมเพรียง: ฉันคิดว่าฉันจำได้ว่าเคยอ่านหรือเคยได้ยินจากอาจารย์คนหนึ่งของฉันว่า ArrayLists เป็นเด็กแนวความคิดที่ไอ้ความพยายามที่จะย้ายจาก Arrays ไปยังกลุ่มรายการประเภทเช่นในขณะที่ครั้งหนึ่งเคย ตัวเลือกเหล่านี้ไม่ใช่ตัวเลือกที่ดีที่สุดอีกต่อไปเนื่องจากมีการพัฒนาเพิ่มเติมเกี่ยวกับคอลเลกชัน

รายการ (ของ T): ArrayList คืออะไร (และหวังว่าจะเป็น)

ความแตกต่างในการใช้งานหน่วยความจำมีความสำคัญมากพอที่รายการ (ของ Int32) ใช้หน่วยความจำน้อยกว่า ArrayList 56% ที่มีประเภทดั้งเดิมเหมือนกัน (8 MB เทียบกับ 19 MB ในการสาธิตที่เชื่อมโยงของสุภาพบุรุษข้างต้น: เชื่อมโยงอีกครั้งที่นี่ ) นี่คือผลลัพธ์ที่ถูกทบต้นด้วยเครื่อง 64 บิต ความแตกต่างนี้แสดงให้เห็นถึงสองสิ่ง: ประการแรก (1), "วัตถุ" ชนิดบรรจุกล่อง Int32 (ArrayList) มีขนาดใหญ่กว่าชนิดดั้งเดิมดั้งเดิม Int32 (รายการ); วินาที (2), ความแตกต่างเป็นเลขยกกำลังเนื่องจากการทำงานภายในของเครื่อง 64- บิต

ดังนั้นอะไรคือความแตกต่างและรายการ (ของ T)คืออะไร? MSDNกำหนดList(Of T)เป็น "... รายการวัตถุที่พิมพ์ได้อย่างแข็งแกร่งซึ่งสามารถเข้าถึงได้โดยดัชนี" ความสำคัญที่นี่คือบิต "ที่พิมพ์อย่างรุนแรง": รายการ (ของ T) 'รู้จัก' ประเภทและเก็บวัตถุเป็นชนิดของพวกเขา ดังนั้นInt32จะถูกเก็บไว้เป็นInt32และไม่ใช่Objectประเภท สิ่งนี้ช่วยลดปัญหาที่เกิดจากการชกมวยและการเลิกทำกล่อง

MSDN ระบุความแตกต่างนี้เท่านั้นที่เล่นเมื่อจัดเก็บประเภทดั้งเดิมและไม่ใช่ประเภทอ้างอิง ด้วยความแตกต่างที่เกิดขึ้นจริงในวงกว้าง: มากกว่า 500 องค์ประกอบ สิ่งที่น่าสนใจยิ่งกว่าคือเอกสารของ MSDN อ่านว่า "เพื่อประโยชน์ของคุณในการใช้งานการระบุประเภทของรายการ (ของ T) แทนการใช้คลาส ArrayList .... "

โดยพื้นฐานแล้ว List (Of T) คือ ArrayList แต่ดีกว่า มันเป็น "เทียบเท่าทั่วไป" ของ ArrayList เช่นเดียวกับ ArrayList ไม่รับประกันว่าจะถูกจัดเรียงจนกว่าจะเรียงลำดับ (ไปที่รูป) รายการ (ของ T) ยังมีฟังก์ชั่นเพิ่มเข้ามา

ฉันเห็นด้วยกับคำถาม - ฉันก็พบ (พบ?) ทางเลือกที่ทำให้สับสนดังนั้นฉันจึงกำหนดทางวิทยาศาสตร์เพื่อดูว่าโครงสร้างข้อมูลใดที่เร็วที่สุด (ฉันทำการทดสอบโดยใช้ VB แต่ฉันคิดว่า C # จะเหมือนกันเนื่องจากทั้งสองภาษา ทำสิ่งเดียวกันในระดับ CLR) คุณสามารถดูผลลัพธ์การเปรียบเทียบที่ดำเนินการโดยฉันที่นี่ (นอกจากนี้ยังมีการอภิปรายเกี่ยวกับประเภทข้อมูลที่ดีที่สุดที่จะใช้ในสถานการณ์ใด)

พวกมันสะกดออกมาได้ดีในระบบ Intellisense เพียงพิมพ์System.Collections หรือSystem.Collections.Generics (ที่ต้องการ) และคุณจะได้รับรายการและคำอธิบายสั้น ๆ ของสิ่งที่มีอยู่

Hashtables / Dictionaries คือประสิทธิภาพ O (1) ซึ่งหมายความว่าประสิทธิภาพไม่ใช่ฟังก์ชันที่มีขนาด สิ่งสำคัญที่ควรรู้

แก้ไข: ในทางปฏิบัติความซับซ้อนของเวลาโดยเฉลี่ยสำหรับการค้นหา Hashtable / พจนานุกรม <> คือ O (1)

คอลเลกชันทั่วไปจะทำงานได้ดีกว่าคู่ที่ไม่ธรรมดาโดยเฉพาะเมื่อทำซ้ำผ่านหลายรายการ เนื่องจากมวยไม่ได้เกิดขึ้นอีกแล้ว

หมายเหตุสำคัญเกี่ยวกับ Hashtable vs Dictionary สำหรับวิศวกรรมการค้าระบบความถี่สูง: หัวข้อความปลอดภัย

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

ดังนั้น Hashtable ยังคงเป็นตัวเลือก 'มาตรฐาน' ในเรื่องนี้

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

โครงสร้างข้อมูลและคอลเลกชัน C # ที่นิยมมากที่สุด

• แถว
• ArrayList
• รายการ
• LinkedList
• พจนานุกรม
• HashSet
• ซ้อนกัน
• คิว
• SortedList

C # .NETมีโครงสร้างข้อมูลที่แตกต่างกันมากมายตัวอย่างหนึ่งที่พบได้บ่อยที่สุดคือ Array อย่างไรก็ตาม C # มาพร้อมกับโครงสร้างข้อมูลพื้นฐานอีกมากมาย การเลือกโครงสร้างข้อมูลที่ถูกต้องเพื่อใช้เป็นส่วนหนึ่งของการเขียนโปรแกรมที่มีโครงสร้างและมีประสิทธิภาพ

ในบทความนี้ฉันจะไปที่โครงสร้างข้อมูล C # ในตัวรวมถึงโครงสร้างใหม่ที่แนะนำใน C # .NET 3.5 โปรดทราบว่าโครงสร้างข้อมูลเหล่านี้ส่วนใหญ่ใช้กับภาษาการเขียนโปรแกรมอื่น

แถว

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

[object type][] myArray = new [object type][number of elements]

ตัวอย่างบางส่วน:

 int[] myIntArray = new int[5];
 int[] myIntArray2 = { 0, 1, 2, 3, 4 };

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

ArrayList

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

    ArrayList myArrayList = new ArrayList();
    myArrayList.Add(56);
    myArrayList.Add("String");
    myArrayList.Add(new Form());

ข้อเสียของโครงสร้างข้อมูล ArrayList คือหนึ่งจะต้องส่งค่าที่แปลงกลับไปเป็นประเภทเดิม:

int arrayListValue = (int)myArrayList[0]

แหล่งข้อมูลและข้อมูลเพิ่มเติมที่คุณสามารถหาได้ที่นี่ :

• โครงสร้างข้อมูล C #
• คอลเลกชันและโครงสร้างข้อมูล
• รายการเทียบกับ IEnumerable เทียบกับ IQueryable กับ ICollection เทียบกับ IDictionary
• System.Collections.Generic Namespace
• System.Collections Namespace

ฉันพบส่วน "เลือกชุดรวม" ของหน้า Microsoft Docs ในหน้าการรวบรวมและโครงสร้างข้อมูลที่เป็นประโยชน์จริง ๆ

C # คอลเล็กชันและโครงสร้างข้อมูล: เลือกชุดสะสม

และเมทริกซ์ต่อไปนี้เพื่อเปรียบเทียบคุณสมบัติอื่น ๆ