快速排序（quickSort）

 

基本思想：

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

算法步骤： 

 

 

对左右区间重复上述，直到各区间只有一个数

例子:

代码实现：

package SortType;

import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args)
    {
        int[] arr={-15,-6,0,7,9,23,54,82,101};
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
    public static void quickSort(int[] arr,int left,int right)
    {
        if(left>=right)
        {
            return;//注意！！！！！！！！记得写
        }
        int i=left,j=right;

        int temp=arr[left];

        while(i<j)
        {
            while (i<j&&arr[j]>=temp)
            {
                j--;
            }
            while(i<j&&arr[i]<=temp)
            {
                i++;
            }
            if(i<j)
            {
                int temp2=arr[j];
                arr[j]=arr[i];
                arr[i]=temp2;
            }
        }
        arr[left]=arr[i];
        arr[i]=temp;
        quickSort(arr,0,i-1);
        quickSort(arr,i+1 ,right);
    }

}

快速排序算法的性能与划分是否对称有关，设计随机化的快速排序算法解决划分对称性问题，将算法编程实现；并回答：对于一个随机化算法，为什么只分析其平均情况下的性能，而不分析其最坏情况下的性能？

答：  快速排序算法的性能与其运行时间与划分是否对称有关。

最坏情况：

1. 两个区域分别包含n-1个元素和1个元素。
2. 时间复杂性 ：                               

最好情况：

1. 每次划分都产生两个大小为n/2的区域：
2. 时间复杂度：                         

快速排序算法的性能取决于划分的对称性。可以采用随机选择策略的快速排序算法。

在数组还没有被划分时，在arr[left,right]中随机选出一个元素作为划分基准，可以使划分基准的选择是随机的，从而可以期望划分是较对称的。

代码实现：

package SortType2;
import java.util.Arrays;
public class QuickSort {
    public static void main(String[] args)
    {
        int[] arr={5,3,1,9,8,2,4,7};
        quick(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
    public static void quick(int[] arr,int left,int right)
    {
        while (left>=right)
        {
            return;
        }
        int i=left;
        int j=right;
        int k=(int)(Math.random()*(right-left+1))+left;//从数组中随机选择一个数作为基准点
        int temp=arr[k];
        arr[k]=arr[left];
        arr[left]=temp;//将以基准点放在数组下标为0的位置--》容易判断
        int firstIndex=left;
        int first=arr[firstIndex];
        while (i<j)
        {
            while (i<j&&arr[j]>=first)
            {
                j--;
            }
            while (i<j&&arr[i]<=first)
            {

               i++;
            }
            if(i<j)
            {
                int temp2=arr[j];
                arr[j]=arr[i];
                arr[i]=temp2;
            }
        }
        arr[firstIndex]=arr[i];
        arr[i]=first;
        quick(arr,left,i-1);
        quick(arr,i+1,right);
    }
}