快速排序

算法思想

1. 洗牌: 把数组打乱,使算法的性能不依赖输入
2. 划分: 选定一个key值,使小于等于key的元素都在key的左边,大于等于key的元素都在key的右边
3. 递归: 对划分好的两部分运用递归继续进行划分,排序
   
   Python3

class Quick:
    @staticmethod
    def qsort(array):
        if len(array) < 2:
            return array
        else:
            pivot = array[0] # pick pivot
            less = [i for i in array[1:] if i <= pivot]
            greater = [i for i in array[1:] if i > pivot]
            return Quick.qsort(less) + [pivot] + Quick.qsort(greater)



if __name__ == "__main__":
    print('quicksort-----')
    a = [2, 4, 5, 2, 3, 8, 9, 87, 22, 45, 10, 1, 6, 99]
    sorted_a = Quick.qsort(a)
    print(a)
    print(sorted_a)
    print(sorted(a))

Java

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Quick {
    private final static int CUTOFF = 7;

    public static void sort(Comparable[] a) {
        // 打乱数组
        List<Comparable> tmp = Arrays.asList(a);
        Collections.shuffle(tmp);
        sort((Comparable[]) tmp.toArray(), 0, a.length - 1);
    }

    private static void sort(Comparable[] a, int lo, int hi) {
        // 小规模部分使用插入排序
        if (lo + CUTOFF >= hi) {
            insertionSort(a, lo, hi);
            return;
        }
        int j = partition(a, lo, hi);
        sort(a, lo, j - 1);
        sort(a, j + 1, hi);
    }

    /*划分*/
    private static int partition(Comparable[] a, int lo, int hi) {
        int i = lo + 1, j = hi;
        Comparable key = a[lo];
        while (true) {
            // 寻找不小于key值的元素
            while (a[i].compareTo(key) <= 0 && i < hi) {
                i++;
            }
            // 寻找不大于key值的元素
            while (a[j].compareTo(key) > 0) {
                j--;
            }
            // 找到key值的位置
            if (i >= j) {
                break;
            }
            // 交换比key值大的和比key值小的元素的位置
            exchange(a, i, j);
        }
        exchange(a, lo, j);
        return j;
    }

    /*交换数组中指定下标的两个元素*/
    private static void exchange(Comparable[] a, int i, int j) {
        Comparable tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

    /*插入排序, 对小规模数组使用*/
    private static void insertionSort(Comparable[] a, int lo, int hi) {
        for (int i = lo; i < hi + 1; i++) {
            int j = i;
            Comparable val = a[i];
            for (; j > lo && val.compareTo(a[j - 1]) < 0; j--) {
                a[j] = a[j - 1];
            }
            a[j] = val;
        }
    }

    public static void main(String[] args) {
        Integer[] a = new Integer[]{2, 4, 5, 2, 3, 8, 9, 87, 22, 45, 10, 1, 6, 99};
        Integer[] b = a.clone();
        System.out.println(Arrays.toString(a));
        Quick.sort(a, 0, a.length - 1);
        Arrays.sort(b);
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(b));
        System.out.println("end");
    }
}

算法分析
稳定性: 不稳定
时间复杂度: 最坏O(n^2) 最好O(nlgn) 平均O(1.39nlgn)
空间复杂度: 最好O(lgn) 最坏O(n)