Question

这更像是一个理论问题：C＃中是否有可能创建一个真正不可变的双向链表？我看到的一个问题是2个相邻节点的相互依赖。

“真正”是指使用只读字段。

Answer 1

这可能与棘手的构造函数逻辑有关。例如

public sealed class Node<T> { 
  readonly T m_data;
  readonly Node<T> m_prev;
  readonly Node<T> m_next;

  // Data, Next, Prev accessors omitted for brevity      

  public Node(T data, Node<T> prev, IEnumerator<T> rest) { 
    m_data = data;
    m_prev = prev;
    if (rest.MoveNext()) {
      m_next = new Node(rest.Current, this, rest);
    }
  }
}

public static class Node {    
  public static Node<T> Create<T>(IEnumerable<T> enumerable) {
    using (var enumerator = enumerable.GetEnumerator()) {
      if (!enumerator.MoveNext()) {
        return null;
      }
      return new Node(enumerator.Current, null, enumerator);
    }
  }
}

Node<string> list = Node.Create(new [] { "a", "b", "c", "d" });

Answer 2

你引起了我的好奇心。 ReadOnlyNode的类很简单，可以定义：

public class ReadOnlyNode<T>
{
   public readonly T Value;
   public readonly ReadOnlyNode<T> Next;
   public readonly ReadOnlyNode<T> Prev;

   public Node(T value, ReadOnlyNode<T> next, ReadOnlyNode<T> prev)
   {
      Value = value;
      Next = next;
      Prev = prev;
   }
}

双链表中readonly的问题在于，对于每个节点，您必须在构造函数中指定该节点的前一个节点和下一个节点，因此如果它们从构造函数外部传递，则必须已经存在。但是，当您调用构造函数时，Node M需要预先存在的Node N作为其“下一个”节点，但是该节点N需要M作为其“前一个”节点才能构造。这会产生“鸡和鸡蛋”的情况，其中N和M都需要首先实例化另一个节点。

但是，这种猫皮肤的方法不止一种。如果列表的每个节点都是从一个ReadOnlyNode的构造函数中递归实例化的，该怎么办？在每个构造函数完成之前，每个级别的属性仍然是可变的，并且对每个节点的引用将存在于其构造函数中，因此在设置完所有内容之前并不是所有内容都已设置并不重要。下面的代码编译，并且给定一个预先存在的IEnumerable将生成一个不可变的双向链表：

public class ReadOnlyNode<T>
{
    public readonly T Value;
    public readonly ReadOnlyNode<T> Next;
    public readonly ReadOnlyNode<T> Prev;

    private ReadOnlyNode(IEnumerable<T> elements, ReadOnlyNode<T> prev)
    {
        if(elements == null || !elements.Any()) 
           throw new ArgumentException(
              "Enumerable must not be null and must have at least one element");
        Next = elements.Count() == 1 
           ? null 
           : new ReadOnlyNode<T>(elements.Skip(1), this);
        Value = elements.First();
        Prev = prev;
    }

    public ReadOnlyNode(IEnumerable<T> elements)
        : this(elements, null)
    {
    }
}


//Usage - creates an immutable doubly-linked list of integers from 1 to 1000
var immutableList = new ReadOnlyNode<int>(Enumerable.Range(1,1000));

您可以将它与任何实现IEnumerable的集合一起使用（几乎所有内置集合都可以使用它，并且您可以使用OfType（）将非泛型ICollections和IEnumerables转换为通用IEnumerables）。唯一需要担心的是调用堆栈;你可以嵌套多少个方法调用是有限制的，这可能导致有限但很大的输入列表上的SOE。

编辑： JaredPar提出了一个非常好的观点;此解决方案使用Count（）和Any（），它们必须考虑Skip（）的结果，因此不能使用这些方法中内置的“快捷方式”，这些方法可以使用集合类的基数属性。这些调用变为线性，这使算法的复杂性变得平方。如果您只是使用IEnumerable的基本成员，那么这将变得更加高效：

public class ReadOnlyNode<T>
{
    public readonly T Value;
    public readonly ReadOnlyNode<T> Next;
    public readonly ReadOnlyNode<T> Prev;

    private ReadOnlyNode(IEnumerator<T> elements, ReadOnlyNode<T> prev, bool first)
    {
        if (elements == null) throw new ArgumentNullException("elements");

        var empty = false;
        if (first) 
           empty = elements.MoveNext();

        if(!empty)
        {
           Value = elements.Current;
           Next = elements.MoveNext() ? new ReadOnlyNode<T>(elements, this, false) : null;
           Prev = prev;
        }
    }

    public ReadOnlyNode(IEnumerable<T> elements)
        : this(elements.GetEnumerator(), null, true)
    {
    }
}

使用此解决方案，您将失去一些更优雅的错误检查，但如果IEnumerable为null，则无论如何都会抛出异常。

Answer 3

是的，您可以创建一个“link-setter”对象，用于设置链接，发送到节点的构造函数，或者使用静态create方法返回“link-setter”。节点中的链接是私有的，只能通过“link-setter”访问，当你使用它们来设置列表时，你就把它们丢弃了。

然而，这是一项非常无用的练习。如果列表是不可变的，那么当一个简单的数组运行得更好时，使用双向链表是毫无意义的。

如何在C＃中创建真正不可变的双向链表？

3 个答案: