Question

def QuickSort(arr:Array[Int],first:Int,last:Int): List[Int] = {
    var pivot:Int = 0
    var temp:Int = 0
    if (first < last) {
        pivot = first
        var i:Int = first
        var j:Int = last;
        while(i<j){
            while(arr(i) <= arr(pivot) && i < last)
                i=i+1
            while(arr(j) > arr(pivot))
                j=j+1
            if(i<j)
            {
                temp = arr(i)
                arr(i) = arr(j)
                arr(j) = temp
            }
        }
        temp = arr(pivot)
        arr(pivot) = arr(j)
        arr(j) = temp
        QuickSort(arr, first, j-1)
        QuickSort(arr, j+1, last)
    }
    arr.toList
  }

您好我是scala的新手，并尝试实施快速排序。程序运行正常，但我想删除while循环，因为我读到了这段时间，并且不建议在scala中使用，因为它们不会返回任何值。

有没有办法在上面的代码中删除while循环。

Answer 1

正如您在此处编写的classic quicksort算法，需要一个可变集合（如Array）和元素值的交换，这需要可变变量（即var）。这些事情在函数式编程中是不受欢迎的，并且在Scala社区中并不受到高度重视。

这是一种类似的方法，更符合FP伦理的精神。

// pseudo-quicksort -- from Array[Int] to List[Int]
def pqs(arr:Array[Int]): List[Int] = arr match {
  case Array()    => List()
  case Array(x)   => List(x)
  case Array(x,y) => if (x < y) List(x,y) else List(y,x)
  case _ => val (below, above) = arr.partition(_ < arr(0))
            pqs(below) ++ List(arr(0)) ++ pqs(above.tail)
}

最好是使用标准库中提供的排序方法之一（sortBy，sortWith，sorted。

Answer 2

不那么优雅，但没有时间：

  def QuickSort(l: List[Int]) : List[Int] = {
    if( l.length == 0) return Nil
    if( l.length == 1 ) return arr
    val pivot = arr(arr.length / 2)
    val lesserThanPivot = l.filter( _ < pivot)
    val equalToPivot = l.filter( _ == pivot)
    val biggerThanPivot = l.filter( _ > pivot)

    QuickSort( lesserThanPivot ) ++ equalToPivot.tail ++ List(pivot) ++ QuickSort(biggerThanPivot)  

  }

Scala - 快速排序中删除while循环

2 个答案: