Question

我创建了长链类，每个链接（类）只知道下一个和上一个链接。当索引不重要时，我认为它优于Arrays。

public class ChainLink
{
    public ChainLink previousLink, nextLink;

    // Accessors here
}

问题：

这种技术究竟叫什么？（我不知道该搜索什么）
是否有.Net类可以做同样的事情？
与阵列或列表有明显的性能影响吗？

我使用的访问者示例

分配给链：

    public ChainLink NextLink {
        get{ return _nextLink;}
        set {
            _nextLink = value;
            if (value != null)
                value._previousLink = this;
        }
    }

    public void InsertNext (ChainLink link)
    {
        link.NextLink = _nextLink;
        link.PreviousLink = this;
    }

缩短链条：

如果我取消分配链的下一个链接，让剩下的链接不被主程序引用，垃圾收集器将为我处理数据。

测试循环引用：

    public bool IsCircular ()
    {
        ChainLink link = this;
        while (link != null) {
            link = link._nextLink;
            if (link == this)
                return true;
        }
        return false;
    }

抵消指数：

    public ChainLink this [int offset] {
        get {
            if (offset > 0 && _nextLink != null)
                return _nextLink [offset - 1];
            if (offset < 0 && _previousLink != null)
                return _previousLink [offset + 1];
            return this;
        }
    }

Answer 1

1）此结构称为双链表

2）此实现存在于C＃到LinkedList

中

3）关于这个主题有很多文章： here或 this SO post

Answer 2

其他人已经回答了关于这个名称和等效的.Net类（一个LinkedList）的问题，但我想我很快就会看到你ChainLink对比的速度数组和List。

我在Foo()类中添加了一个方法ChainLink，以便为每个对象实例访问一些内容：

public class ChainLink
{
    public ChainLink previousLink, nextLink;

    // Accessors here
    public void Foo()
    { }
}

第一种方法创建一个数组，然后计算访问数组中每个项目所需的时间：

private void TestArray()
{
    // Setup the Array
    ChainLink[] Test = new ChainLink[1000000];
    for (int i = 0; i < 1000000; i++)
        Test[i] = new ChainLink();

    // Use a Stopwatch to measure time
    Stopwatch SW;
    SW = new Stopwatch();
    SW.Start();

    // Go through items in the array
    for (int i = 0; i < Test.Length; i++)
        Test[i].Foo();

    // Stop timer and report results
    SW.Stop();
    Console.WriteLine(SW.Elapsed);
}

接下来，我创建了一个方法来使用List<T>并计算访问其中每个项目所需的时间：

private void TestList()
{
    // Setup the list
    List<ChainLink> Test = new List<ChainLink>();
    for (int i = 0; i < 1000000; i++)
        Test.Add(new ChainLink());

    // Use a Stopwatch to measure time
    Stopwatch SW;
    SW = new Stopwatch();
    SW.Start();

    // Go through items in the list
    for (int i = 0; i < Test.Count; i++)
        Test[i].Foo();

    // Stop timer and report results
    SW.Stop();
    Console.WriteLine(SW.Elapsed);
}

最后，我创建了一种方法来使用你的ChainLink并继续浏览下一个项目，直到不再有：

private void TestChainLink()
{
    // Setup the linked list
    ChainLink Test = new ChainLink();
    for (int i = 0; i < 1000000; i++)
    {
        Test.nextLink = new ChainLink();
        Test = Test.nextLink;
    }

    // Use a Stopwatch to measure time
    Stopwatch SW;
    SW = new Stopwatch();
    SW.Start();

    // Go through items in the linked list
    while (Test != null)
    {
        Test.Foo();
        Test = Test.nextLink;
    }

    // Stop timer and report results
    SW.Stop();
    Console.WriteLine(SW.Elapsed);
}

运行这些中的每一个都会产生一些显而易见的结果：

TestArray（）：00：00：00.0058576

TestList（）：00：00：00.0103650

TestChainLink（）：00：00：00.0000014

多次迭代揭示了相似的数字。

总之，您的ChainLink比数组快4,100倍，比List快约7,400倍。

链链接类

我使用的访问者示例

2 个答案: