代码改变世界

单链表与List<T>究竟哪个遍历速度快?

2010-07-02 01:21 by Jeffrey Zhao, ... 阅读, ... 评论, 收藏, 编辑

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一些说得的很严重的事情,大家还得自己考证一下。

使用Live Messenger联系我