数据结构值排序算法（三）-快速排序

基本思想：

快速排序采用的思想是分治思想。

第一趟排序：快速排序是找出一个元素（理论上可以随便找一个）作为基准(pivot),然后对数组进行分区操作,使基准左边元素的值都不大于基准值,基准右边的元素值 都不小于基准值，如此作为基准的元素调整到排序后的正确位置。

递归排序：第二步就是对高段位和地段为两部分进行递归排序。

一趟快速排序的算法的步骤是：
1）设置两个变量low、high，排序开始的时候：low=0，high=N-1；
2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3）从high开始向前搜索，即由后开始向前搜索(high--)，找到第一个小于key的值A[high]，将A[high]和A[low]互换；
4）从i开始向后搜索，即由前开始向后搜索(low++)，找到第一个大于key的A[low]，将A[low]和A[high]互换；
5）重复第3、4步，直到low=high；

一趟快速排序的算法的图解是：

QuickSortClass.java

public class QuickSortClass {   private int[] array;   public int[] getArray() {   return array;   }   public void setArray(int[] array) {   this.array = array;   }   //快速排序     public void quikSort(){         QuikSort(0,array.length-1);     }      //递归的快速排序    private void QuikSort(int low,int high){         if(low>=high){                return;         }else{                int pivot = array[low];  //以第一个元素为基准                int partition =partition(low,high,pivot);  //对数组进行划分，比pivot小的元素在低位段，比pivot大的元素在高位段                              QuikSort(low,partition-1);   //对划分后的低位段进行快速排序                QuikSort(partition+1,high);  //对划分后的高位段进行快速排序         }     }      //以pivot为基准对下标low到high的数组进行划分 ,low 数组段的最小下标 ,high 数组段的最大下标 , pivot 划分的基准元素 , 划分完成后基准元素所在位置的下标    private int partition(int low,int high,int pivot){                 while(low<high){                             while(low<high &&array[high]>=pivot){  //从右端开始扫描，定位到第一个比pivot小的元素                       high--;  //如果array[high]比基准pivot大，就不管，继续向前移动              }                swap(low,high);  //如果array[high]比基准pivot小，就交换low和high                             while(low<high &&array[low]<=pivot){  //从左端开始扫描，定位到第一个比pivot大的元素                       low++;    //如果array[low]比基准pivot小，就不管，继续向后移动              }                swap(low,high);  //如果array[low]比基准pivot大，就交换low和high                       }         return low;          }     //交换数组中两个元素的数据    private void swap(int low,int high){         int temp = array[high];         array[high] = array[low];         array[low] = temp;     }  }

TestQuickSort.java

public class TestQuickSort {public static void main(String[] args) {// TODO Auto-generated method stub       int[] list={25,24,6,65,11,43,22,51};       QuickSortClass qs=new QuickSortClass();       System.out.println("快排前的数组是：");       for(int i=0;i<list.length;i++){       System.out.print(list[i]+" ");       }      qs.setArray(list);      qs.quikSort();      int[] list2= qs.getArray();       System.out.println();       System.out.println("快排后的数组是：");       for(int i=0;i<list2.length;i++){       System.out.print(list2[i]+" ");       }}}

算法分析：

在最差的情况下，划分有n个元素构成的数组需要进行n次比较和n次移动，因此划分所需的时间为O(n).在最差的情况下，每次主元会将数组划分成为一个大数组和一个空数组。这个大数组的规模是在上次划分的基础上减一。该算法需要(n-1)+(n-2)+...+2+1=O(n2).

在最佳的情况下，每次主元会将数组划分成为规模大致相等的部分。设T(n)标识使用快速排序算法堆包含n个元素的数组排序所需要的时间，因此

                        T(n)=T(n/2)+T(n/2)+n

快速排序的T(n)=O(nlogn)