C# Academy · บทเรียน

เลือกคอลเลกชัน

ข้อแลกเปลี่ยนและประสิทธิภาพ

เลือกคอลเลกชัน เป็นบทเรียน C# Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน C# Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส C# Academy มีบทเรียนทั้งหมด 4 บทเรียน

เริ่มจากคำถามหนึ่งข้อ

การเลือกชุดข้อมูลเริ่มจากคำถามหนึ่งข้อ: คุณจะเข้าถึงข้อมูลอย่างไร ตามตำแหน่ง ตามคีย์ หรือเพียงตรวจสอบการมีอยู่

List, Dictionary และ HashSet ต่างตอบโจทย์รูปแบบการเข้าถึงที่แตกต่างกัน เลือกเครื่องมือให้ตรงกับรูปแบบ แล้วโค้ดของคุณจะยังคงรวดเร็วและอ่านง่าย

เข้าถึงตามตำแหน่ง: รายการ

หากลำดับมีความสำคัญและคุณเข้าถึงรายการด้วยดัชนี ให้เลือก List<T> รายการนี้รักษาลำดับการแทรกและให้การเข้าถึงด้วยดัชนีใน O(1)

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

var steps = new List<string> { "mix", "bake", "cool" };
string first = steps[0]; // O(1) by index

เข้าถึงตามคีย์: พจนานุกรม

หากคุณค้นหาสิ่งต่าง ๆ ด้วยตัวระบุที่ไม่ซ้ำกัน ให้เลือก Dictionary<K,V> ซึ่งจับคู่คีย์กับค่าโดยเฉลี่ยใน O(1)

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

var users = new Dictionary<int, string> {
    [101] = "Ann",
    [102] = "Bob"
};
string name = users[101];

การมีอยู่และความไม่ซ้ำกัน: HashSet

หากคุณสนใจเพียงว่ามีค่าอยู่หรือไม่ หรือต้องปฏิเสธค่าซ้ำ ให้เลือก HashSet<T> โดย Contains มีความซับซ้อนโดยเฉลี่ย O(1)

ตัวอย่างเช่น URL ที่เยี่ยมชมแล้ว สิทธิ์ที่อนุญาต หรือแท็กที่ไม่ซ้ำกัน ไม่มีค่าข้อมูลแนบอยู่ มีเพียงการมีอยู่ของสมาชิกเท่านั้น

var visited = new HashSet<string>();
if (visited.Add(url)) {
    // first time seeing this url
}

ตารางต้นทุน

ต้นทุนโดยเฉลี่ย: การเข้าถึงด้วยดัชนีของ List มีความซับซ้อน O(1) แต่ Contains มีความซับซ้อน O(n) การค้นหาใน Dictionary และ HashSet มีความซับซ้อน O(1)

List.Add ที่ท้ายรายการมีความซับซ้อนแบบเฉลี่ยสะสม O(1) แต่การแทรกหรือลบตรงกลางมีความซับซ้อน O(n) การเพิ่มและการลบใน Dictionary และ HashSet มีความซับซ้อนโดยเฉลี่ย O(1)

// List:       index O(1),  Contains O(n)
// Dictionary: by-key O(1), no index
// HashSet:    Contains O(1), no value, no index

การใช้ Contains ของรายการเป็นสัญญาณเตือน

การเรียก list.Contains ซ้ำ ๆ ภายในลูปเป็นกับดัก O(n ยกกำลังสอง) เพราะการตรวจสอบแต่ละครั้งต้องไล่ดูรายการทั้งหมด

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

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var allow = new HashSet<int> { 2, 4, 6 };
        foreach (int n in new[] { 1, 2, 3, 4 })
            if (allow.Contains(n)) Console.Write(n + " ");
    }
}

เมื่อคุณต้องการทั้งคีย์และลำดับ

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

ลองเก็บ List ไว้สำหรับลำดับควบคู่กับ Dictionary สำหรับการค้นหา หรือใช้ SortedDictionary<K,V> เพื่อเก็บคีย์ตามลำดับที่เรียงแล้ว โดยมีต้นทุน O(log n)

var sorted = new SortedDictionary<string, int>();
sorted["b"] = 2;
sorted["a"] = 1;
// enumerates a then b, in key order

การแลกเปลี่ยนด้านหน่วยความจำ

ชุดข้อมูลที่อิงแฮชแลกหน่วยความจำกับความเร็ว Dictionary และ HashSet ใช้ช่องเก็บข้อมูลภายใน จึงใช้หน่วยความจำมากกว่า List หรืออาร์เรย์ที่จัดเก็บอย่างกระชับ

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

ให้ Program พึ่งพาอินเทอร์เฟซ

ลายเซ็นของเมธอดควรขอชนิดข้อมูลที่เฉพาะเจาะจงน้อยที่สุดเท่าที่ใช้งานได้ รับ IEnumerable<T> เพื่ออ่านข้อมูล รับ IReadOnlyList<T> สำหรับการอ่านด้วยดัชนี และรับ IDictionary<K,V> สำหรับการเข้าถึงด้วยคีย์

วิธีนี้แยกผู้เรียกออกจากชนิดข้อมูลจริงที่คุณเลือกใช้ ทำให้คุณเปลี่ยนการนำไปใช้งานในภายหลังได้โดยไม่ทำให้ลายเซ็นเสียหาย

int Sum(IEnumerable<int> values) {
    int total = 0;
    foreach (int v in values) total += v;
    return total;
}

ตัวอย่างแบบลงมือทำ

การนับคำที่ไม่ซ้ำกันในข้อความใช้ชุดข้อมูลสองชนิดร่วมกัน HashSet ติดตามคำที่พบแล้ว ส่วน Dictionary นับจำนวนครั้งที่พบ

แต่ละชนิดทำหน้าที่ของตนได้ดี: set บังคับให้ค่าไม่ซ้ำกัน ส่วนพจนานุกรมจับคู่คำกับความถี่ โดยทั้งคู่มีต้นทุนเฉลี่ย O(1) ต่อการดำเนินการ

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var counts = new Dictionary<string, int>();
        foreach (var w in "a b a c b a".Split(' '))
            counts[w] = counts.GetValueOrDefault(w) + 1;
        Console.WriteLine(counts["a"]); // 3
    }
}

รายการตรวจสอบเพื่อการตัดสินใจ

ถามตามลำดับดังนี้: ฉันต้องการแผนผังคีย์ไปยังค่าหรือไม่ ใช้ Dictionary ฉันต้องการเพียงความไม่ซ้ำกันหรือการตรวจสอบการมีอยู่หรือไม่ ใช้ HashSet

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

ตรวจสอบความเข้าใจ

นำรายการตรวจสอบเพื่อการตัดสินใจไปใช้กับความต้องการที่เป็นรูปธรรม

ทบทวน

เลือกตามรูปแบบการเข้าถึง: List สำหรับลำดับที่มีลำดับและเข้าถึงด้วยดัชนี Dictionary สำหรับการค้นหาจากคีย์ไปยังค่า และ HashSet สำหรับความไม่ซ้ำกันและการตรวจสอบการมีอยู่

จับตาความซับซ้อนแบบบิกโอ: หลีกเลี่ยง List.Contains ในลูปที่ทำงานบ่อย ใช้ประโยชน์จากการค้นหาด้วยแฮชใน O(1) และเขียนโปรแกรมให้พึ่งพาอินเทอร์เฟซ เพื่อให้ตัวเลือกของคุณยังคงยืดหยุ่น

คำถามที่พบบ่อย

บทเรียน “เลือกคอลเลกชัน” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “เลือกคอลเลกชัน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส C# Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส C# Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “เลือกคอลเลกชัน”

ข้อแลกเปลี่ยนและประสิทธิภาพ คุณปฏิบัติ C# Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน C# Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน C# Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “เลือกคอลเลกชัน” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน C# Academy นี้ได้ไหม

ได้ บทเรียน C# Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ C# Academy