是否可以编写一个不可变的双向链表？

Question

我觉得问这个有点愚蠢，但我目前正在学习函数式编程并完成了一个关于创建单链表的练习，这让我开始思考，是否有可能创建一个不可变的双链表？

假设列表A::B，在构建的时候，A需要知道B，但是B也需要知道A。我在Scala里一直在做这个，所以不确定是否具体到 Scala，但我无法想象它是如何工作的。

我不是在寻找替代品，因为我什么都不需要这个，我只是好奇。

Answer 1

是的，这是可能的。但通常不会这样做，因为与单链表不同，双链表没有任何可以在例如删除一个元素时重用的子结构。此外，这样的列表似乎没有做任何不可变的Vector 做不到的事情。

尽管如此，还是把它写下来吧，因为它很有趣。

简化问题：循环二元素“列表”

作为热身，看一下简化的问题：一个循环的二元素“列表”，其中两个节点相互引用：

case class HalfRing(val value: Int)(otherHalf: => HalfRing) {
  def next = otherHalf
}

object HalfRing {
  def fullRing(a: Int, b: Int): HalfRing = {
    lazy val ha: HalfRing = HalfRing(a){hb}
    lazy val hb: HalfRing = HalfRing(b){ha}
    ha
  }
}

这确实有效，我们可以构建这个小的两节点数据结构，并在其上循环运行几百万次迭代：

var r = HalfRing.fullRing(42, 58)
for (i <- 0 until 1000000) {
  r = r.next
  if (i % 100001 == 0) println(r.value)
}

输出：

58
42
58
42
58
42
58
42
58
42

循环演示的是：这是一个实际的数据结构，而不是一些奇怪的嵌套函数家族，这些函数在访问元素几次后就会破坏堆栈。

---

不可变双链表

我决定用双链接连接的节点来表示列表，两端有两个明确的Nil-元素：

sealed trait DLL[+A] extends (Int => A)
case class LeftNil[+A]()(n: => DLL[A]) extends DLL[A] {
  def next = n
  def apply(i: Int) = next(i)
}
case class RightNil[+A]()(p: => DLL[A]) extends DLL[A] {
  def prev = p
  def apply(i: Int) = 
    throw new IndexOutOfBoundsException("DLL accessed at " + i)
}
case class Cons[+A](value: A)(p: => DLL[A], n: => DLL[A]) extends DLL[A] {
  def next = n
  def prev = p
  def apply(i: Int) = if (i == 0) value else next(i - 1)
}

apply-part 几乎无关紧要，我添加它只是为了以后可以检查和打印内容。有趣的问题是：我们如何才能真正实例化这样一个列表？下面是一种将单链表转换为双链表的方法：

object DLL {
  def apply[A](sll: List[A]): DLL[A] = {
    def build(rest: List[A]): (=> DLL[A]) => DLL[A] = rest match {
      case Nil => RightNil[A]() _
      case h :: t => {
        l => {
          lazy val r: DLL[A] = build(t){c}
          lazy val c: DLL[A] = Cons(h)(l, r)
          c
        }
      }
    }
    lazy val r: DLL[A] = build(sll){l}
    lazy val l: DLL[A] = LeftNil(){r}
    l
  }
}

这里发生的事情本质上与上面的二元素环相同，但重复了多次。我们只是以加入两个半环的相同方式继续加入片段，除了这里我们首先将小的Cons-元素加入到列表的长尾，最后加入LeftNil和第一个Cons .

再次，一个小演示，一个“迭代器”，它在列表上来回运行几百万次迭代，偶尔打印当前元素：

val dll = DLL((42 to 100).toList)

println((1 to 20).map(dll))

@annotation.tailrec 
def bounceBackAndForth(
  dll: DLL[Int], 
  maxIters: Int, 
  direction: Int = +1
): Unit = {
  if (maxIters <= 0) println("done")
  else dll match {
    case ln: LeftNil[Int] => bounceBackAndForth(ln.next, maxIters - 1, +1)
    case rn: RightNil[Int] => bounceBackAndForth(rn.prev, maxIters - 1, -1)
    case c: Cons[Int] => {
      if (maxIters % 100003 == 0) println(c.value)
      if (direction < 0) {
        bounceBackAndForth(c.prev, maxIters - 1, -1)
      } else {
        bounceBackAndForth(c.next, maxIters - 1, +1)
      }
    }
  }
}

bounceBackAndForth(dll, 1000000)

// cs_XIIIp4

备注：我不觉得递归build-方法特别直观，没在纸上潦草几分钟就写不下来。说实话，每次成功我还是有点惊讶。