排序算法之快速排序

快速排序：虽然名字中有快速二字，但其在最糟糕的情况下时间复杂度为O(N^2),在平均情况下，快速排序的时间复杂度为O(nlogn).
快速排序也是一种归并算法，我们在待排序序列中选择一个对象作为基准，将小于它和大于它的分别分成两个子序列，然后分别对着两个子序列对排序。

示例：

3 2 0 5 -1 9 1 4

第一次取sign = 3,左指针指向3，右指针从最后一位开始循环，
4 > 3,右指针左移一位，为1，1 < 3, 将1放到3的位置，
左指针右移一位，为2, 2 < 3,继续右移，0 < 3,继续右移，
5 > 3, 将5放到1的位置，右指针继续左移，9 > 3,
继续右移， -1 < 3, 将-1放到5的位置，左指针右移，
这时左右指针重逢，将sign放在重逢的位置，继续下一次递归
第一次递归后，源数据分成了两组
1 2 0 -1 | 3 9 5 4
继续在这两组上做递归

 C++实现（递归）：

#include <iostream>
using namespace std;

template<typename T>
void quick_sort(T arr[], int left, int right) {
    if (right <= left) return;
    T var = arr[left];
    int _left = left;
    int _right = right;
    while (_left != _right) {
        while ((_right > _left) && (arr[_right] >= var)) {
            _right--;
        }   
        arr[_left] = arr[_right];
        while ((_left < _right) && (arr[_left] <= var)) {
            _left++;
        }   
        arr[_right] = arr[_left];
    }   
    arr[_left] = var;
    quick_sort(arr, left, _left - 1); 
    quick_sort(arr, _left + 1, right);
}

template<typename T>
void print(T arr, int len) {
    for (int i = 0; i < len; i++) {
        if (i + 1 < len) {
            std::cout << arr[i] << ",";
        } else {
            std::cout << arr[i] << std::endl;
        }   
    }   
}

int main() {
    double arr[] = {1.3, 4.35, 0, 12.34, 33.5, -1, 3.4, 5.56, 8.67};
    std::cout << "before sort:" << std::endl;
    int len = sizeof(arr) / sizeof(arr[0]);
    print(arr, len);
    quick_sort(arr, 0, len - 1);
    std::cout << "after sort:" << std::endl;
    print(arr, len);
}

 Python实现（递归）：

def quick_sort(lists, left, right):
    if (right <= left):
        return
    val = lists[left]
    _left = left
    _right = right
    while (_left < _right):
        while ((_right > _left) and (lists[_right] > val)):
            _right -= 1
        lists[_left] = lists[_right]
        while ((_left < _right) and (lists[_left] < val)):
            _left += 1
        lists[_right] = lists[_left]
    lists[_right] = val
    quick_sort(lists, left, _left - 1)
    quick_sort(lists, _left + 1, right)

lists = [3, -1, 4, 0, 34, 35, 2, 100, 56, 7, 8]
lens = len(lists)
print("before sort:", lists)
quick_sort(lists, 0, lens - 1)
print("after sort:", lists)

 C++实现（非递归）：

其实递归转非递归就是用栈保存每一个代排序的集合的首尾元素，下次去除首尾进行partition排序，直到栈为空。

 

#include <iostream>
#include <stack>
using namespace std;

template<typename T>
int partition(T arr[], int left, int right) {
    T var = arr[left];
    int _left = left;
    int _right = right;
    while (_left != _right) {
        while ((_right > _left) && (arr[_right] >= var)) {
            _right--;
        }
        arr[_left] = arr[_right];
        while ((_left < _right) && (arr[_left] <= var)) {
            _left++;
        }
        arr[_right] = arr[_left];
    }   
    arr[_left] = var;
    return _left;
}

template<typename T>
void quick_sort(T arr[], int left, int right) {
    if (right <= left) return;
    int mid = partition(arr, left, right);
    std::stack<T> data_stack;
    data_stack.push(left);
    data_stack.push(mid - 1); 
    data_stack.push(mid + 1); 
    data_stack.push(right);
    while (!data_stack.empty()) {
        int high = data_stack.top();
        data_stack.pop();
        int low = data_stack.top();
        data_stack.pop();
        mid = partition(arr, low, high);
        if (mid - 1 > low) {
            data_stack.push(low);
            data_stack.push(mid - 1);
        }
        if (mid + 1< high) {
            data_stack.push(mid + 1);
            data_stack.push(high);
        }
    }
}

template<typename T>
void print(T arr, int len) {
    for (int i = 0; i < len; i++) {
        std::cout << arr[i] << std::endl;
    }
}

int main() {
    double arr[] = {1.3, 4.35, 0, 12.34, 33.5, -1, 3.4, 5.56, 8.67};
    std::cout << "before sort:" << std::endl;
    int len = sizeof(arr) / sizeof(arr[0]);
    print(arr, len);
    quick_sort(arr, 0, len - 1);
    std::cout << "after sort:" << std::endl;
    print(arr, len);
}