【Scala编程】函数式风格编写排序算法

有关Scala编程实例

在刚开始学习一门编程语言的时候，总是想去写一些比较大的程序和项目，但是由于基础不扎实，往往欲速则不达。所以，只能一步一步来，通过一些经典的小例子来实践和锻炼，最终不断加深编程的技能，坚持下来，相信慢慢就能够变得熟练。

冒泡排序、选择排序、插入排序的一般写法

这三种排序方法没有太多要说的东西，这里的编程方式和指定式方式没什么差别。
这里之所以使用Array数据，因为Array数组是可变的对象序列，其元素值可以改变，而List类对象的元素是不可变的。
这里的写法不是函数式风格的，其中用到了var可变变量，并且每个函数都是用副作用的，因为这些函数改变了输入数组Array的内容。

  def bubbleSort(arr: Array[Int]): Unit = {
    for(i <- 0 until arr.length-1; j <- 0 until arr.length-1-i){
      if(arr(j) > arr(j+1)){
        val tmp = arr(j)
        arr(j) = arr(j+1)
        arr(j+1) = tmp
      }
    }
  }

  def selectSort(arr: Array[Int]): Unit = {
    for(i <- 0 until arr.length-1){
      var min_ind = i
      for(j <- i+1 to arr.length-1) {
        if(arr(j) < arr(min_ind)){
          min_ind = j
        }
      }
      if(min_ind != i){
        val tmp = arr(i)
        arr(i) = arr(min_ind)
        arr(min_ind) = tmp
      }
    }
  }

  def insertSort(arr: Array[Int]): Unit = {
    for(i <- 1 until arr.length){
      val tmp = arr(i)
      var j = i-1
      while(j > -1 && arr(j) > tmp){
        arr(j+1) = arr(j)
        j -= 1
      }
      arr(j+1) = tmp
    }
  }

基于模式匹配的插入排序

insertSort函数中采用模式匹配做拆分列表，将分离出来的最左侧的元素插入到按照顺序排列的所在的位置，使用递归调用的方式不断对列表进行拆分。
在指令式的风格中，使用循环的方式，依次取出最左侧的元素，然后插入到从左侧起按照顺序排列的位置。与这种方式有所不同的是，采用递归的函数式的方式，首先递归地对列表进行拆分，然后再按照顺序进行插入。递归的方式结构简洁，但是不容易理解。

  def insertSort(xs: List[Int]): List[Int] = xs match  {
    case List() => List()
    case x :: xs1 => insert(x, insertSort(xs1))
  }

  def insert(x: Int, xs: List[Int]): List[Int] = xs match {
    case List() => List(x)
    case y :: ys =>
      if (x <= y) x :: xs
      else y :: insert(x, ys)
  }

归并排序

归并排序的工作原理：首先如果列表长度为零或仅有一个元素，它就已经排好序了，因此可以不加改变地返回。长列表可以拆分为两个子列表，每个包含大概一半的原列表元素。每个子列表采用对排列函数的递归调用完成排序，然后再用归并操作把产生的两个排好序的列表合并在一起。

这里先贴出代码再解释：

def merge(a: List[Int], b: List[Int]): List[Int] = (a,b) match {
  case (Nil, _) => b
  case (_, Nil) => a
  case (x::xs, y::ys) =>
    if(x <= y) x :: merge(xs, b)
    else y :: merge(a, ys)
}

def mergeSort(lst: List[Int]): List[Int] = {
  if(lst.length < 2) lst
  else{
    val (first, second) = lst.splitAt(lst.length/2)
    merge(mergeSort(first), mergeSort(second))
  }
}

在mergeSort函数中，利用分治策略将子序列进行递归分割，然后再将不断分割的子序列从底向上地合并起来；在merge函数中，通过模式匹配的方式合并两个子序列，在(x::xs, y::ys)对应的模式下，中缀操作符::被当作构造器模式（实际上，存在名为scala.::的类，它可以创建非空列表），这样将列表做拆分，按照元素大小进行排序合并。另外，merge函数使用尾递归的方式来优化性能。

下面是更加函数式风格的写法：
使用函数内函数可以这样写，整体性更佳。对于归并排序的通用实现来说，你可能希望对于待排序列表元素类型不做限制，并同时希望对于用来做元素比较的函数不做限制。这里通过类型参数化来泛化类型，通过使用了柯里化方式，加入比较函数作为参数。

  def msort[T](less: (T, T) => Boolean)
              (xs: List[T]): List[T] = {
    def merge(xs: List[T], ys: List[T]): List[T] =
      (xs, ys) match {
        case (Nil, _) => ys
        case (_, Nil) => xs
        case (x :: xs1, y :: ys1) =>
          if(less(x, y)) x :: merge(xs1, ys)
          else y :: merge(xs, ys1)
      }

    val n = xs.length / 2
    if(n == 0) xs
    else {
      val (ys, zs) = xs splitAt n
      merge(msort(less)(ys), msort(less)(zs))
    }
  }
}

快速排序

指令性风格的快速排序：

  def qsort(xs: Array[Int]): Unit = {
    def swap(i: Int, j: Int): Unit = {
      val t = xs(i); xs(i) = xs(j); xs(j) = t
    }

    def sort1(l: Int, r: Int): Unit = {
      val pivot = xs((l+r) / 2)
      var i = l; var j = r
      while(i <= j){
        while(xs(i) < pivot) i += 1
        while(xs(j) > pivot) j -= 1
        if(i <= j){
          swap(i, j)
          i += 1
          j -= 1
        }
      }
      if(l < j) sort1(l, j)
      if(j < r) sort1(i, r)
    }
    sort1(0, xs.length-1)
  }
}

函数式风格的快速排序：

  def quickSort(xs: Array[Int]): Array[Int] = {
    if(xs.length <= 1) xs
    else{
      val pivot = xs(xs.length / 2)
      Array.concat(
        quickSort(xs filter (pivot >)),
                  xs filter (pivot ==),
        quickSort(xs filter (pivot <))
      )
    }
  }

更加简洁的快速排序：

def quickSort(lst: List[Int]): List[Int] = {
    val p = lst.head
    val (before, after) = lst.tail.partition(_ < p)
    quickSort(before) ++ (p :: quickSort(after))
}

转载请注明作者Jason Ding及其出处
GitCafe博客主页(http://jasonding1354.gitcafe.io/)
Github博客主页(http://jasonding1354.github.io/)
CSDN博客(http://blog.csdn.net/jasonding1354)
简书主页(http://www.jianshu.com/users/2bd9b48f6ea8/latest_articles)
Google搜索jasonding1354进入我的博客主页