Question

以下代码是将列表拆分为两部分的递归代码。

def split(lst:List[Int],lst1:List[Int],lst2:List[Int]): (List[Int],List[Int])=
lst match{
  case Nil => (lst1,lst2)
  case hd::Nil => (lst1,hd::lst2)
  case hd::tail => split(tail.init,lst1:::List(hd), tail.last::lst2)
}

我想使用堆栈将此递归函数转换为迭代函数。

Answer 1

我尝试使用堆栈来解决问题

但它只会给代码带来混乱和复杂性

如果您只想要一个简单的解决方案，这就是答案

def split(lst: List[Int], lst1: List[Int], lst2: List[Int]): (List[Int], List[Int]) = 
(lst1 ::: lst.take(lst.length / 2), lst.drop(lst.length /2) ::: lst2)

Answer 2

这是使用队列的版本。

def iSplit(xs: List[Int]) = {
    val first = scala.collection.mutable.Queue[Int]()
    val second = scala.collection.mutable.Queue[Int]()

    xs.grouped(2).foreach { e =>
      e match {
        case List(a, b) =>
          second.enqueue(a, b)
          first.enqueue(second.dequeue)
        case List(a) =>
          second.enqueue(a)
      }
    }
    (first.toList, second.toList)
  }

我们可以将first更改为堆栈，但代价是反向

def iSplit(xs: List[Int]) = {
  val first = scala.collection.mutable.Stack[Int]()
  val second = scala.collection.mutable.Queue[Int]()

  xs.grouped(2).foreach { e =>
    e match {
      case List(a, b) =>
        second.enqueue(a, b)
        first.push(second.dequeue)
      case List(a) =>
        second.enqueue(a)
    }
  }
  (first.toList.reverse, second.toList)
}

但second的问题在于我们想要在一端添加内容并从另一端删除内容。这不是堆栈，而是队列。

所以我认为你应该告诉你的教授，队列效果会更好：）

Scala：使用Stack将递归函数转换为迭代

2 个答案: