快速排序的Java实现、性能分析以及适用场景

1.快速排序的Java实现：

代码如下：

package com.zm.testSort;
/**
 * 快速排序的标准实现
 * @author zm
 *
 */
public class QuickSort {
    public static void getQuickSort(int[] a) {
        getQuickSort(a, 0, a.length-1); 
    }
    public static void getQuickSort(int[] a, int lo, int hi) {
        if(hi <= lo) {
            return;
        }
        int j = partition(a, lo, hi);
        getQuickSort(a, lo, j);
        getQuickSort(a, j+1, hi);

    }
    public static int partition(int[] a, int lo, int hi) {
        int i = lo;
        int j = hi;
        int temp = a[lo];
        while(i < j) {
            while(i < j && a[j] >= temp) {
                j--;
            }
            a[i] = a[j];
            while(i < j && a[i] <= temp) {
                i++;
            }
            a[j] = a[i];
        }
        a[i] = temp;
        int k = i;
        return k;
    }
    public static void main(String[] args) {
        int[] a = {3, 5, 1, 2, 6, 4, 7, 11, 23, 44, 3, 34, 8, 23, 6, 9};
        getQuickSort(a);
        System.out.print("快速排序：");
        for(int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

}

优化后的快速排序：(任何改进算法都需通过实验来确定改进的效果)

package com.zm.testSort;
/**
 * 三向切分
 * 优化后的快速排序，如果数组中存在大量重复元素，则该算法比标准的快排要效率高很多，
 * @author zm
 */
public class OptimizeQuickSort {
    public static void getOptimizeQuickSort(int[] a) {
        getOptimizeQuickSort(a, 0, a.length-1);
    }
    /**
     * 这段排序代码的切分能够将和切分元素相等的元素归位，这样它们就不会被包含在递归调用的子数组之中
     */
    public static void getOptimizeQuickSort(int[] a, int lo, int hi) {
        if(lo >= hi) {
            return;
        }
        int lt = lo, i = lo + 1, gt = hi;//三向切分  分为四段：小于基准的值-[lo, lt-1]、等于基准的值-[lt, i-1]、未确定的值-[i, gt]、大于基准的值-[gt+1, hi]
        int v = a[lo];//设置基准
        while(i <= gt) {
            if(a[i] < v) {//如果小于基准，则交换a[lt]和a[i]、lt++、i++
                swap(a, lt++, i++);
            }else if(a[i] > v) {//如果大于基准，则交换a[i]和a[gt]、gt--
                swap(a, i, gt--);
            }else {//如果等于基准，则i++
                i++;
            }
        }
        getOptimizeQuickSort(a, lo, lt-1);//取小于基准的所有值
        getOptimizeQuickSort(a, gt+1, hi);//取大于基准的所有值
    }
    public static void swap(int[] a, int b, int c) {
        int temp = a[b];
        a[b] = a[c];
        a[c] = temp;
    }

    public static void main(String[] args) {
        int[] a = {3, 5, 1, 2, 6, 4, 7, 11, 23, 44, 3, 34, 8, 23, 6, 9};
        getOptimizeQuickSort(a);
        System.out.print("优化后的快速排序：");
        for(int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

}

2.快速排序的性能分析：

时间复杂度：
1. 最好情况：O(nlog2(n))
2. 平均情况：O(nlog2(n))
3. 最坏情况：O(n^2)
空间复杂度：O(log2(n))
稳定性：不稳定(相同元素的相对位置会改变)

3.适用场景

3.1：一般应用中，比其他排序快得多，适用于数组长度比较大的情况，对于小数组，快速排序比插入排序慢。

3.2：如果数组中有大量重复元素，则三向取样的快排比标准的快排效率高很多。