数据结构与算法——快速排序算法

算法描述

       快速排序是基于分治的思想，是冒泡排序的改进型。首先在数组中选择一个基准点（该基准点的选取可能会影响快速排序算法的效率），然后分别从数组的两端扫描数组。设两个指示标志（low指向起始位置，high指向末尾位置），首先从后半部分开始，如果发现有元素比该基准点的值小，就交换low和high位置的值，然后从前半部分开始扫描，发现有元素大于基准点的值，就交换low和high位置的值，如此往复循环，直到low>=high，然后把基准点的值放到high这个位置，一次排序就完成了。以后采用递归的方式分别对前半部分和后半部分排序，以达到整个序列有序的目的。

代码实现：

public class QuickSort {

    public void quickSort(int[] arr,int low,int high) {
        int pivot;
        if(low<high) {
            pivot=partition(arr,low,high);
            quickSort(arr,low,pivot-1);
            quickSort(arr,pivot+1,high);
        }
    }
    
    public int partition(int[] arr,int low,int high) {
        int pivotKey;
        pivotKey=arr[low];
        while(low<high) {
            while(low<high && arr[high]>=pivotKey) {
                high--;
            }
            swap(arr,low,high);
            while(low<high && arr[low]<=pivotKey) {
                low++;
            }
            swap(arr,low,high);
        }
        return low;
    }
    
    public void swap(int[] arr,int i,int j) {
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}

优化一：优化选取的基准点

public class QuickSort {
    /*
     *    三数取中(选取基准点)
     * 
     */
    public void quickSort(int[] arr,int low,int high) {
        int pivot;
        if(low<high) {
            pivot=partition(arr,low,high);
            quickSort(arr,low,pivot-1);
            quickSort(arr,pivot+1,high);
        }
    }
    public int partition(int[] arr,int low,int high) {
        int pivotKey;
        int mid=(low+high)/2;
        if(arr[low]>arr[high]) {
            swap(arr,low,high);
        }
        if(arr[mid]>arr[high]) {
            swap(arr,mid,high);
        }
        if(arr[mid]>arr[low]) {
            swap(arr,low,mid);
        }
        pivotKey=arr[low];
        while(low<high) {
            while(low<high && arr[high]>=pivotKey) {
                high--;
            }
            swap(arr,low,high);
            while(low<high && arr[low]<=pivotKey) {
                low++;
            }
            swap(arr,low,high);
        }
        return low;
        
    }
    public void swap(int[] arr,int i,int j) {
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}

优化二：优化不必要的交换

public class QuickSort {
    public void quickSort(int[] arr,int low,int high) {
        int pivot;
        if(low<high) {
            pivot=partition(arr,low,high);
            quickSort(arr,low,pivot-1);
            quickSort(arr,pivot+1,high);
        }
    }
    public int partition(int[] arr,int low,int high) {
        int pivotKey;
        int mid=(low+high)/2;
        if(arr[low]>arr[high]) {
            swap(arr,low,high);
        }
        if(arr[mid]>arr[high]) {
            swap(arr,mid,high);
        }
        if(arr[mid]>arr[low]) {
            swap(arr,low,mid);
        }
        pivotKey=arr[low];
        while(low<high) {
            while(low<high && arr[high]>=pivotKey) {
                high--;
            }
            arr[low]=arr[high];//采用替换而不是交换的方式进行操作
            while(low<high && arr[low]<=pivotKey) {
                low++;
            }
            arr[high]=arr[low];//采用替换而不是交换的方式进行操作
        }
        arr[low]=pivotKey;
        return low;
    }
    public void swap(int[] arr,int i,int j) {
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}

快速排序算法的复杂度分析

        最优情况：最优情况下是指每次区间划分的结果都是基准关键字的左右两边长度相等或者相差为1，即选取的基准关键字为待排序的记录的中间值。此时的时间复杂度为O(nlogn)。

        最坏情况：最坏情况下，待排序的序列为正序或者逆序，每次划分只得到一个比上一次划分少一个记录的子序列，注意另一个为空。此时的时间复杂度为O(n²)。

        空间复杂度：就空间复杂度来说，主要是递归造成的栈空间的使用，最好情况，递归树的深度为log₂n，其空间复杂度为O(logn)，最坏情况，需要进行n-1递归调用，其空间复杂度为O(n)，平均情况，空间复杂度为O(logn)。

        算法的稳定性：快速排序是一种不稳定的排序方法。