使用合并排序计算反转次数

Question

我需要使用Merge Sort:计算反转次数

object Example {
 def msort(xs: List[Int]): List[Int] = {
    def merge(left: List[Int], right: List[Int]): Stream[Int] = (left, right) match {
      case (x :: xs, y :: ys) if x < y => Stream.cons(x, merge(xs, right))
      case (x :: xs, y :: ys) => Stream.cons(y, merge(left, ys))
      case _ => if (left.isEmpty) right.toStream else left.toStream
    }
    val n = xs.length / 2
    if (n == 0) xs
    else {
      val (ys, zs) = xs splitAt n
      merge(msort(ys), msort(zs)).toList
    }
  }                                              
  msort(List(8, 15, 3))                           
}

我想我必须在中计数（其中y < y，match中的第二行）

case (x :: xs, y :: ys) => Stream.cons(y, merge(left, ys))

然而，当我尝试时，我失败了。

我该怎么做？

更新：

带有累加器的版本：

def msort(xs: List[Int]): List[Int] = {
    def merge(left: List[Int], right: List[Int], inversionAcc: Int = 0): Stream[Int] = (left, right) match {
      case (x :: xs, y :: ys) if x < y => Stream.cons(x, merge(xs, right, inversionAcc))
      case (x :: xs, y :: ys) => Stream.cons(y, merge(left, ys, inversionAcc + 1))
      case _ => if (left.isEmpty) right.toStream else left.toStream
    }
    val n = xs.length / 2
    if (n == 0) xs
    else {
      val (ys, zs) = xs splitAt n
      merge(msort(ys), msort(zs)).toList
    }
  } 

如何轻松返回inversionAcc？我想，我只能像这样返回元组的一部分：

def merge(left: List[Int], right: List[Int], invariantAcc: Int = 0): (Stream[Int], Int)

不过看起来不太好。

更新2：

而且它实际上没有正确计数，我找不到错误在哪里。

Answer 1

这是我的Frege解决方案的Scala端口。

object CountInversions {
  def inversionCount(xs: List[Int], size: Int): (Int, List[Int]) = 
    xs match {
        case _::_::_ => { //If the list has more than one element
          val mid = size / 2
          val lsize = mid
          val rsize = size - mid
          val (left, right) = xs.splitAt(mid)
          val (lcount, lsorted) = inversionCount(left, lsize)
          val (rcount, rsorted) = inversionCount(right, rsize)
          val (mergecount, sorted) = inversionMergeCount(lsorted, lsize, rsorted,
            rsize, 0, Nil)
          val count = lcount + rcount + mergecount
          (count, sorted)
        }
        case xs => (0, xs)
     }
  def inversionMergeCount(xs: List[Int], m: Int, ys: List[Int], n: Int, 
    acc: Int, sorted: List[Int]): (Int, List[Int]) = 
      (xs, ys) match {
        case (xs, Nil) => (acc, sorted.reverse ++ xs)
        case (Nil, ys) => (acc, sorted.reverse ++ ys)
        case (x :: restx, y :: resty) => 
          if (x < y) inversionMergeCount(restx, m - 1, ys, n, acc, x :: sorted)
          else if (x > y) inversionMergeCount(xs, m, resty, n - 1, acc + m, y :: sorted)
          else inversionMergeCount(restx, m - 1, resty, n - 1, acc, x :: y :: sorted)
      }
}

Answer 2

如果解决方案不必严格发挥作用，那么您只需添加一个简单的计数器：

object Example {
  var inversions = 0
  def msort(xs: List[Int]): List[Int] = {
    def merge(left: List[Int], right: List[Int]): Stream[Int] = (left, right) match {
      case (x :: xs, y :: ys) if x < y => Stream.cons(x, merge(xs, right))
      case (x :: xs, y :: ys) =>
        inversions = inversions + 1
        Stream.cons(y, merge(left, ys))
      case _ => if (left.isEmpty) right.toStream else left.toStream
    }
    val n = xs.length / 2
    if (n == 0) xs
    else {
      val (ys, zs) = xs splitAt n
      merge(msort(ys), msort(zs)).toList
    }
  }
}
Example.msort(List(8, 15, 3))
println(Example.inversions)

如果它必须保持功能，那么您需要创建一个累加器，并通过所有方法调用将其线程化，并从返回结果中包含累加器值的每个函数返回一个Pair，然后对每个合并收敛的累加器数值求和。（我的功能不是很好，在尝试简单的var方法之前，我已经尝试过在功能上解决这个问题。）