快速排序--基于scala实现

排序算法–介绍

快速排序由于排序效率在同为 O(N*logN) 的几种排序方法中效率较高，因此经常被采用，再加上快速排序思想----分治法也确实实用.
快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。
该方法的基本思想是：
1．先从数列中取出一个数作为基准数。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。

示例

以一个数组作为示例:取数组的第一个元素作为基准值,i:起始索引,j:末尾索引.

索引	0	1	2	3	4	5	6	7	8	9
元素值	70	3	44	90	66	39	79	69	99	55

初始状态:i = 0,j = 9, 数组 A = a[i] =a[0]= 70.
从后往前开始遍历,寻找一个小于等于A的数,发现当j =9时符合条件,则将j=9对应的值–55赋值给
刚才的a[0],即a[0] = a[9],数组变为:

索引	0	1	2	3	4	5	6	7	8	9
元素值	55	3	44	90	66	39	79	69	99	55

那么70跑到哪去了呢?其实就是一个变量A保存了它的值.
由于索引在左半部分,直接从i++开始:寻找一个大于A的数,然后赋值给a[9],发现i=3满足条件,
所以:a[9] = a[3] = 90 ,此时数组变为:

索引	0	1	2	3	4	5	6	7	8	9
元素值	55	3	44	90	66	39	79	69	99	90

同理,再次重复上述过程,j–,寻找一个小于等于A的数:a[7] = 69,将其赋值给a[3],此时数组变为:

索引	0	1	2	3	4	5	6	7	8	9
元素值	55	3	44	69	66	39	79	69	99	90

其实就是完成了基本思想的第二个步骤:
分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
由于从左边开始:i++;从右边开始j–,那么最终有个临界条件即i == j ,此时i=j = 7,将刚才保存在A的基准值70赋值给a[7],这样就完成了左半区间的数都小于等于基准值70,右半区间的所有值都大于基准值70,最后对左右半区间分别重复上述的工作.直到区间只有1个数为止.
总结如下:

1. i =L; j = R; 将基准数形成第一个a[i]。
2. j–由后向前找比它小的数，找到后以此数填前一个a[i]中。
3. i++由前向后找比它大的数，找到后也以此数填到前一个a[j]中。
4. 再重复执行2，3二步，直到i==j，将基准数填入a[i]中。
5. 最后,分别对2个子区间重复1,2,3步骤,直到区间只有1个数为止.

代码实现

package cn.demo

object Quick_Sort {
  def main(args: Array[String]): Unit = {
    //测试数组
    val list = List(70,3,44,90,66,39,79,69,99,55)
    println(quick_sort(list))
  }
  //快速排序的实现
  def quick_sort(list:List[Int]):List[Int] = {
    list match {
      // 当list为Null时,直接返回NIl,也就是空
      case Nil => Nil
      case List() => List()
      // 当数组不为空时,从list中提取出首元素:head,和剩余元素组成的列表:tail.
      case head::tail => {
        // 列表的一个分区方法,查看源码,将列表按给定的条件分成2个子列表.
        val (left,right)=tail.partition(_ < head)
        // 对2个子区间递归调用快速排序,++ 是一个方法:将2个列表组成一个列表.
        quick_sort(left) ++ (head::quick_sort(right))
      }
    }
  }
}

结果:

List(3, 39, 44, 55, 66, 69, 70, 79, 90, 99)

进程完成，退出码 0

参考:
菜鸟教程
白话经典算法系列之六 快速排序 快速搞定