單鏈表與List究竟哪個遍歷速度快?

原文地址爲:單鏈表與List究竟哪個遍歷速度快?

firelong雄文又起,不過說實話,可能是這篇文章寫的太簡單了,其中的理由和結論都聽得不是很明白。當然有一段話的意思很清楚(原話):“C#事件的背後是一個委託鏈表(單鏈表),單鏈表的遍歷調用性能遠低於數組鏈表(List<T>)”。這句話讓我比較納悶,因爲從我的直覺來說,兩種做法之間即使性能有差距,也不該是“遠高於”啊。不過我提出這個疑問之後,firelong迴應到(還是原話)“間接指針移動,和i++哪個快慢很難辨析嗎?”於是我想,還是做個試驗吧。試驗代碼很簡單:

public class Node
{
public Node Next;
public int Value;
}

public class Item
{
public int Value;
}

class Program
{
static Node GetSingleList(int length)
{
Node root = null;
for (int i = 0; i < length; i++)
{
root = new Node { Next = root, Value = 0 };
}

return root;
}

static List<Item> GetList(int length)
{
return Enumerable.Range(0, length)
.Select(_ => new Item { Value = 0 }).ToList();
}

static void Main(string[] args)
{
int length = 10000;
int iteration = 100000;
int count = 0;

var root = GetSingleList(length);
var watch1 = Stopwatch.StartNew();
for (int t = 0; t < iteration; t++)
{
var node = root;
while (node != null)
{
count += node.Value;
node = node.Next;
}
}
Console.WriteLine("{0} (Node List)", watch1.Elapsed);

GC.Collect();

var list = GetList(length);
var watch2 = Stopwatch.StartNew();
for (int t = 0; t < iteration; t++)
{
for (int i = 0; i < list.Count; i++)
{
count += list[i].Value;
}
}
Console.WriteLine("{0} (List<Item>)", watch2.Elapsed);
}
}

使用Release模式編譯,並且保證VS不會Attach Debugger之後,執行幾遍結果如下:

00:00:02.0731861 (Node List)
00:00:02.4602990 (List<Item>)

00:00:02.3176291 (Node List)
00:00:02.2912638 (List<Item>)

00:00:02.1539642 (Node List)
00:00:02.4635390 (List<Item>)

我的直覺是這樣的:如果使用List<T>來遍歷,除了i++操作以外,還需要計算偏移量,根據List內部的數組來找到下一個對象的地址,再根據這個地址去訪問下一個對象,而單向鏈表的遍歷做的事情會少一些,只要一個接一個的訪問就行了。從結果上看,總體說來差別不大,並沒有出現firelong所說的“單向鏈表遍歷性能遠低於List<T>”的情況出現。而且事實上,這點性能真的有關係嗎?這裏累計遍歷了10億個元素,才產生了零點幾秒的差距,而對於一個事件來說,您會爲它添加多少個Handler,又會調用多少次呢?

我一直不願意多談性能方面的問題,因爲我實在沒有什麼可談的,該談的都談過了。而且,我在這方面也沒吃過什麼苦頭,即使遇到一些小問題,也是因爲代碼寫的效率不高,簡單優化以後就沒有問題了。不過firelong的新文章談的是設計,例如覺得C#——應該說是.NET的事件機制很糟糕,yield功能沒有什麼用,讓C#語法變的很臃腫等等。我喜歡語言,我很喜歡談語言設計,所以這些方面倒有可以討論的地方。只是最近事情有些多,以後我會寫的,您可以關注我的新博客

這篇文章寫的比較匆忙,也沒有什麼太可取的內容,便先簡單試試看這趟水有多深吧。

補充說明三點:

有朋友提出,數組裏的對象在內存裏的分佈是連續的,單向鏈表不連續,因此考慮到如果換頁,緩存等關係,基於數組的效率會比較高。我的看法是:如果您遍歷的是int[],那麼每個int值的在內存裏自然是連續的,但是這裏訪問的是Item[]這樣的引用元素的數組,連續分佈的只是對象的地址,而要獲得最終對象,還得再根據地址去訪問某個內存,它就不能保證連續性了。同樣道理,有朋友說,真實情況下Node這樣的對象不是連續訪問的,我認爲這個差別也不會偏袒向其中任何一方。也有朋友認爲,不管怎麼說數組裏的地址是連續的,局部性還是更好。不過我認爲,對於單向鏈表來說,如訪問Node的Value時,Next也會一併加載到緩存裏去,同一個對象的字段是緊挨着的也是.NET出於局部性的考慮。

還有朋友指出,數組訪問它不會傻傻得i++再去訪問下標,它會優化。這沒錯,如果您用Item[]來代替List<Item>就會發現性能的確有提高(但同樣相差不大)。但是,firelong同學說的是List<T>,它不是數組,而是基於數組的容器。由於List<T>是可變的,因此JIT是否真會對其進行優化還是個未知數,我傾向於理解爲“不是”。不過現在,我只是通過小實驗來看看究竟相差如何。

也有朋友說,Delegate不一定就是用單向鏈表或是List<T>保存的啊。是的,已經有朋友在firelong的原帖提出了。不過我針對的只是firelong關於“單項鍊表和List<T>”之間的遍歷性能比較。我一直很奇怪,firelong從上一篇就開始說“性能相差很大”,“遠低於”,“致命影響”之類的很嚴重的詞彙,但是真的嚴重到什麼程度卻始終不給出任何說法。因此我現在也只是開個頭,想說明firelong一些說得的很嚴重的事情,大家還得自己考證一下。


轉載請註明本文地址:單鏈表與List究竟哪個遍歷速度快?
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章