排序算法之快速排序

快速排序是对冒泡排序的一种改进。

它的基本思想是：通过一次排序将数据分割成两部分，其中一部分的数据都比另外一部分的数据都要小，然后在对这两部分进行相同操作

基本流程
1．先从数列中取出一个数作为基准数。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。

动态演示

python实现

def quickSort(datas: list):
    def func(begin: int, end: int):
        if begin == end or begin == end + 1: return
        front: int = begin
        rear: int = end
        pivot = datas[front]
        while front < rear:
            while front < rear and datas[rear] >= pivot: rear -= 1
            datas[front] = datas[rear]
            while front < rear and datas[front] <= pivot: front += 1
            datas[rear] = datas[front]
        datas[front] = pivot
        func(begin, front)
        func(front + 1, end)
        
    func(0, len(datas) - 1)

def main():
    size: int = 20
    l = []
    for i in range(0, size):
        l.append(math.floor(random() * size * 10))
    print("排序前:", l)
    quickSort(l)
    print("排序后:", l)

数据量	10^4	10^5	10^6	10^7
耗时/ms	43.2	601.1	7179.9	87891.9

C++ 实现

    template<typename T>
    void quickSort(T* arr, int size) {
     
        if (size == 0)return;
        int front = 0, rear = size - 1;
        T pivot = arr[0];
        while (front < rear) {
     
            while (front < rear && arr[rear] >= pivot) {
      --rear; }
            arr[front] = arr[rear];
            while (front < rear && arr[front] <= pivot) {
      ++front; }
            arr[rear] = arr[front];
        }
        arr[front] = pivot;
        quickSort(arr, front);
        quickSort(arr + front + 1, size - 1 - front);
    }

数据量	10^4	10^5	10^6	10^7
耗时/ms	0.8397	10.713	133.032	3680.29

java实现

    public static <T extends Comparable<T>> void quickSort(T[] array) {
     
        _quickSort(array, 0, array.length - 1);
    }

    private static <T extends Comparable<T>> void _quickSort(T[] array, int begin, int end) {
     
        if (begin == end + 1 || begin == end) return;
        int front = begin, rear = end;
        T pivot = array[front];
        while (front < rear) {
     
            while (front < rear && array[rear].compareTo(pivot) >= 0) --rear;
            array[front] = array[rear];
            while (front < rear && array[front].compareTo(pivot) <= 0) ++front;
            array[rear] = array[front];
        }
        array[front] = pivot;
        _quickSort(array, begin, front - 1);
        _quickSort(array, front + 1, end);
    }

数据量	10^4	10^5	10^6	10^7
耗时/ms	4.0	115.3	440.5	4059.8

算法分析

平均时间复杂度 O(nlogn)
最坏时间复杂度 O(n²) 对一个降序序列排序，退化成冒泡排序
稳定性:不稳定