LinkedList的迭代速度比List快？

Question

由于某种原因，我的LinkedList似乎胜过List 。 我有一个LinkedList因为在代码的一部分中，我不得不重新排列很多子级。 重新排列后的所有内容都只是遍历数据并执行计算。 我以前只是使用Iterator遍历LinkedList ，但是后来我认为我应该同时存储相同元素的List ，以便可以更快地遍历它们。 不知何故，添加List并对其进行迭代对于完全相同的事情来说要慢得多。 不确定如何实现，因此任何信息都将有所帮助。

这里大概是我希望更快的代码：

class Program {
    public static void Main(string[] args) {
        var originalList = new List<Thing>();
        for (var i = 0; i < 1000; i++) {
            var t = new Thing();
            t.x = 0d;
            t.y = 0d;
            originalList.Add(t);
        }
        var something = new Something(originalList);

        for (var i = 0; i < 1000; i++) {
            var start = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
            something.iterate();
            time += (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond) - start;
            Console.Out.WriteLine(time / (i + 1));
        }
    }

    class Thing {
        public double x {get; set;}
        public double y {get; set;}
    }

    class Something {
                    private List<Thing> things;
        private LinkedList<Thing> things1 = new LinkedList<Thing>();
        private List<Thing> things2 = new List<Thing>();

        public Class(List<Thing> things) {
            this.things = things;

            for (var i = 0; i < things.Count; i++) {
                things1.AddLast(things[i]);
                things2.Add(things[i]);
            }
        }

        public void iterate() {
            //loops like this happen a few times, but the list is never changed, only the
            //objects properties in the list
            for (var i = 0; i < things2.Count; i++) {
                                    var thing = things2[i];
                thing.x += someDouble;
                thing.y += someOtherDouble;
            }
        }
    }
}

这是我首先要做的，我认为应该慢一些：

class Program {
    public static void Main(string[] args) {
        var originalList = new List<Thing>();
        for (var i = 0; i < 1000; i++) {
            var t = new Thing();
            t.x = 0d;
            t.y = 0d;
            originalList.Add(t);
        }
        var something = new Something(originalList);

        for (var i = 0; i < 1000; i++) {
            var start = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
            something.iterate();
            time += (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond) - start;
            Console.Out.WriteLine(time / (i + 1));
        }
    }

    class Thing {
        public double x {get; set;}
        public double y {get; set;}
    }

    class Something {
        private List<Thing> things;
        private LinkedList<Thing> things1 = new LinkedList<Thing>();

        public Class(List<Thing> things) {
            this.things = things;

            for (var i = 0; i < things.Count; i++) {
                things1.AddLast(things[i]);
            }
        }

        public void iterate() {
            //loops like this happen a few times, but the list is never changed, only the
            //objects properties in the list
            var iterator = things1.First;
            while (iterator != null) {
                var value = iterator.Value;
                value.x += someDouble;
                value.y += someOtherDouble;
                iterator = iterator.Next;
            }
        }
    }
}

Answer 1

由于无法编译，因此很难进行验证，因此我无法在自己的计算机上运行它，但是仍然存在一些大问题：

• 您不应该使用DateTime.Now来衡量性能。 而是使用Stopwatch ，它可以进行高保真时间测量，例如：

 var stopwatch = Stopwatch.StartNew(); //do stuff here stopwatch.Stop(); double timeInSeconds = stopwatch.Elapsed.TotalSeconds; 

• 您的算术在以下几行中存在根本性的缺陷：

 DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond 

滴答表示为整数（此处为long ），除法的结果不是实数，而是被截断。 例如55/7 55 / 7 = 7 。 因此，这绝对不是稳定的基准测试方法。

此外，使用更多元素运行基准测试，并确保您在“发布”模式下进行测试。

Answer 2

根据您的代码，性能降低的原因不是迭代，而是添加元素到List<T> 。

这篇文章在比较列表和LinkedList方面做得很好。 List<T>基于数组，它被分配在一个连续的块中，因此当您向其中添加更多元素时，数组的大小将被调整，这会导致代码性能下降。

如果您来自C ++世界，则C＃中的List<T>等同于STD中的vector<T> ，而LinkedList<T>等同于STD中的list<T> 。