算法——快速排序

来源:互联网 发布:淘宝宝贝编辑用什么 编辑:程序博客网 时间:2024/06/04 18:14

算法描述

分治法:
1.分解:数组A[p…r]被划分为两个子数组A[p..q-1]和A[q+1,r],使得A[q]为大小居中的数,左侧A[p..q-1]中的每个元素都小于等于它,而右侧A[q+1,r]中的每个元素都大于等于它,其中计算下标q也是划分过程的一部分。
2.解决:通过递归调用快速排序,对于子数组A[p..q-1]和A[q+1,r]进行排序
3.合并:因为子数组都是原址排序的,所以不需要合并,数组A[p..r]已经有序。

QuickSort(A,p,r){ if p<r    q=Partition(A,p,r)    QuickSort(A,p,q-1)    QuickSort(A,q+1,r)}

Partition算法

分区算法,定义一个主元(pivot),它的任务是把主元放在数组中的某个位置,使得以主元为分界,小于等于它的数都在左边,大于它的数都在右边,最后返回主元的索引。
因为数组一开始是无序的,这意味着我们要不断调整元素的位置。
一遍单向扫描法
这里写图片描述
一遍扫描法的思路是,用两个指针将数组划分为三个区间,扫描指针(scan_pos)左边是确认小于主元的,扫描指针到某个指针(next_bigger_pos)中间为未知的,因此我们将第二个指针称为未知区间末指针,末指针的右边区间为确认大于主元的元素。
伪代码

partition(A,p,r) pivot = A[p] scan_pos = p+1 next_bigger_pos=r while(scan_pos <= next_bigger_pos){    if(A[scan_pos]<=pivot)       scan_pos++     else        swap(A,scan_pos,next_bigger_pos)       next_bigger_pos--       }swap(A,next_bigger_pos,p)//主元定位return next_bigger_pos

Java实现代码

static int partition(int[] arr,int p, int r){  int pivot = arr[p];  int scan_pos = p+1;  int next_bigger_pos =r;  while(scan_pos<=next_bigger_pos){    if(arr[scan_pos]<=pivot){       scan_pos++;      } else{       Util.swap(arr,scan_pos,next_bigger_pos);       next_bigger_pos--;      }   }}

双向扫描法

双向扫描的思路是,头尾指针往中间扫描,从左找到大于主元的元素,从右找到小于主元的元素二者交换,继续扫描,直到左侧无大元素,右侧无小元素。
伪代码:

Partition(A,p,r)   pivot = A[p] //设中心点为第一个元素while(p<r)     while(p<r&&arr[r]>= pivot) r--; //从右侧寻找更小的     arr[p] = arr[r] //r是大元素,往左侧交换     while(p<r&&arr[p]<=pivot)p++;//从左侧寻找更大的     arr[r] = arr[p]; //p是小元素,往右侧交换   arr[p] = pivot //p恰好是主元应该呆的地方   return p

这里没有用到swap函数,但也有swap过程。 该算法比较简洁精妙,需要好好品味一下。Partition算法的时间复杂度为Θ(n),因为它对每个元素只扫描一次。

//分区算法2static int partition2(int[] arr,int p,int r){  int pivot = arr[p];   while(p<r){     while(p<r && arr[r]>=pivot)       r--; //从右侧寻找更小的      arr[p] = arr[r];//小的往左侧     while(p<r&&arr[p]<=pivot)       p++;      arr[r]=arr[p];//大的往右侧调  }    arr[p] = pivot;    System.out.println(p+Arrays.toString(arr));    return p;}

性能分析
最坏的划分

如果每次划分都是n-1个元素和0个元素进行递归,即每次partition得到的中心点都是第一个元素,那时间度是线性级数,为Θ(n²)。

最好的划分

每次子问题的规模都是n/2,那么其时间复杂度为Θ(nlgn)

平衡划分

快排的平均运行时间更接近于其最好情况。