HashSet<T> t = new HashSet<T>();
// add 10 million items
Dictionary<K, V> t = new Dictionary<K, V>();
// add 10 million items.
.Containsวิธีของใครจะกลับเร็วกว่ากัน?
เพื่อชี้แจงความต้องการของฉันคือฉันมีวัตถุ 10 ล้านรายการ (สตริงจริงๆ) ที่ฉันต้องตรวจสอบว่ามีอยู่ในโครงสร้างข้อมูลหรือไม่ ฉันจะไม่ทำซ้ำ
คำตอบ:
ฉันคิดว่าคุณหมายถึงDictionary<TKey, TValue>ในกรณีที่สอง? HashTableเป็นคลาสที่ไม่ใช่คลาสทั่วไป
คุณควรเลือกคอลเลกชันที่เหมาะสมสำหรับงานตามความต้องการจริงของคุณ คุณต้องการแมปแต่ละคีย์กับค่าหรือไม่? ถ้าใช่ให้ใช้Dictionary<,>. หากคุณเพียงHashSet<>ดูแลเกี่ยวกับว่ามันเป็นชุดที่ใช้
ฉันคาดหวังHashSet<T>.ContainsและDictionary<TKey, TValue>.ContainsKey(ซึ่งเป็นการดำเนินการที่เทียบเคียงได้โดยสมมติว่าคุณกำลังใช้พจนานุกรมของคุณอย่างสมเหตุสมผล) ในการดำเนินการโดยทั่วไป - พวกเขาใช้อัลกอริทึมเดียวกันโดยพื้นฐานแล้ว ฉันเดาว่ารายการที่Dictionary<,>มีขนาดใหญ่ขึ้นคุณจะมีโอกาสที่จะเป่าแคชได้Dictionary<,>มากกว่าHashSet<>แต่ฉันคาดว่าจะไม่มีนัยสำคัญเมื่อเทียบกับความเจ็บปวดจากการเลือกประเภทข้อมูลที่ไม่ถูกต้องในแง่ของสิ่งที่คุณเป็น พยายามที่จะบรรลุ
Dictionaryเหตุผลอื่นอยู่แล้วคุณควรใช้สิ่งนั้น
จากเอกสาร MSDN สำหรับ Dictionary <TKey, TValue>
"การดึงค่าโดยใช้คีย์นั้นเร็วมากใกล้เคียงกับO (1)เนื่องจากคลาส Dictionary ถูกใช้เป็นตารางแฮช "
ด้วยหมายเหตุ:
"ความเร็วในการดึงข้อมูลขึ้นอยู่กับคุณภาพของอัลกอริทึมการแฮชประเภทที่ระบุไว้สำหรับ TKey"
ฉันรู้ว่าคำถาม / โพสต์ของคุณเก่า - แต่ในขณะที่กำลังหาคำตอบสำหรับคำถามที่คล้ายกันฉันก็เจอสิ่งนี้
หวังว่านี่จะช่วยได้ เลื่อนลงไปที่ส่วนหมายเหตุเพื่อดูรายละเอียดเพิ่มเติม https://msdn.microsoft.com/en-us/library/xfhwa508(v=vs.110).aspx
นี่คือโครงสร้างข้อมูลที่แตกต่างกัน นอกจากนี้ยังไม่มีเวอร์ชันทั่วไปของHashTable.
HashSetมีค่าประเภท T ซึ่งHashTable(หรือDictionary) มีคู่คีย์ - ค่า ดังนั้นคุณควรเลือกการรวบรวมข้อมูลที่คุณต้องการจัดเก็บ
คำตอบที่ยอมรับสำหรับคำถามนี้ไม่สามารถตอบคำถามได้อย่างถูกต้อง! เกิดขึ้นเพื่อให้คำตอบที่ถูกต้อง แต่คำตอบนั้นไม่ได้แสดงโดยหลักฐานที่พวกเขาให้มา
คำตอบนั้นแสดงให้เห็นว่าการค้นหาคีย์บน a DictionaryหรือHashSetเร็วกว่าการค้นหาในไฟล์List. ซึ่งเป็นเรื่องจริง แต่ไม่น่าสนใจและไม่น่าแปลกใจหรือพิสูจน์ได้ว่ามีความเร็วเท่ากัน
ฉันใช้รหัสด้านล่างเพื่อเปรียบเทียบเวลาในการค้นหาและข้อสรุปของฉันก็คือพวกเขามีความเร็วเท่ากัน (หรืออย่างน้อยถ้ามีความแตกต่างแสดงว่าผลต่างอยู่ในค่าเบี่ยงเบนมาตรฐานของความเร็วนั้นด้วย)
โดยเฉพาะอย่างยิ่งการค้นหา 100,000,000 ครั้งใช้เวลาระหว่าง 10 ถึง 11.5 วินาทีสำหรับทั้งสองอย่างสำหรับฉันในการทดสอบนี้
รหัสทดสอบ:
private const int TestReps = 100_000_000;
[Test]
public void CompareHashSetContainsVersusDictionaryContainsKey()
{
for (int j = 0; j < 10; j++)
{
var rand = new Random();
var dict = new Dictionary<int, int>();
var hash = new HashSet<int>();
for (int i = 0; i < TestReps; i++)
{
var key = rand.Next();
var value = rand.Next();
hash.Add(key);
dict.TryAdd(key, value);
}
var testPoints = Enumerable.Repeat(1, TestReps).Select(_ => rand.Next()).ToArray();
var timer = new Stopwatch();
var total = 0;
timer.Restart();
for (int i = 0; i < TestReps; i++)
{
var newKey = testPoints[i];
if (hash.Contains(newKey))
{
total++;
}
}
Console.WriteLine(timer.Elapsed);
var target = total;
Assert.That(total == target);
timer.Restart();
for (int i = 0; i < TestReps; i++)
{
var newKey = testPoints[i];
if (dict.ContainsKey(newKey))
{
total++;
}
}
Console.WriteLine(timer.Elapsed);
Assert.That(total == target * 2);
Console.WriteLine("Set");
}
}