Question

我们给了一个链接列表类，我们需要在这个类中创建一个函数，该函数将一个函数作为参数，并在列表的每个节点上调用该函数。我们可以递归地或通过循环来做到这一点，但我不确定为什么无法使它起作用。

目前，我正在使用while循环，如果该节点确实等于null，则在该节点上调用该函数，然后转到下一个节点。

cellClicked(tdID, i, j) {
   console.log(tdID, i, j)
}

Answer 1

此类任务最好通过（尾）递归来完成（此外，除非完全确定您为什么需要它，否则永远不要使用var ...并且{{ 1}}也是可以避免的，请使用null）：

Option

Answer 2

这里有3种使用Algebraic Data Types (ADT)的可能性。

第一种object-oriented方式：

sealed trait LinkedListNode[A] {
  def calleachnode(inputfunction : A => Unit): Unit 
}

case class BranchNode[A](value:A, next: LinkedListNode[A]) extends LinkedListNode[A] {
  def calleachnode(inputfunction : A => Unit): Unit = {
    inputfunction(value)
    next.calleachnode(inputfunction)
  }
}

case class LeafNode[A](value:A) extends LinkedListNode[A] {
  def calleachnode(inputfunction : A => Unit): Unit = {
    inputfunction(value)
  }
}

或者，如果您愿意，可以使用模式匹配：

sealed trait LinkedListNode[A] {

  def calleachnode(inputfunction : A => Unit): Unit = this match {
    case BranchNode(value, next) => 
        inputfunction(value)
        next.calleachnode(inputfunction)
    case LeafNode(value) =>
        inputfunction(value)
  }
}

case class BranchNode[A](value:A, next: LinkedListNode[A]) extends LinkedListNode[A]

case class LeafNode[A](value:A) extends LinkedListNode[A]

您可以使用以下方法测试这些解决方案：

 val lln = BranchNode(12, LeafNode(2))
 lln.calleachnode((i) => println(i * 2))

现在更多functional的使用ADT的方式：

sealed trait LinkedListNode[A] 

case class BranchNode[A](value:A, next: LinkedListNode[A]) extends LinkedListNode[A]

case class LeafNode[A](value:A) extends LinkedListNode[A]


def calleachnode[A](listNode: LinkedListNode[A], inputfunction : A => Unit): Unit = listNode match {
  case BranchNode(value, next) => 
    inputfunction(value)
    calleachnode(next, inputfunction)
  case LeafNode(value) =>
    inputfunction(value)
}

测试看起来有些不同：

val lln = BranchNode(12, LeafNode(2))
calleachnode[Int](lln, (i) => println(i * 2))

创建一个函数，将一个函数作为参数并在每个链表项上调用它

2 个答案: