算法——快速排序

算法描述

分治法：
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)，因为它对每个元素只扫描一次。

//分区算法2
static 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)

平衡划分

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