经典排序算法之快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。
快速排序由C. A. R. Hoare在1962年提出。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。–百度百科

// 双侧扫描法
function sortQuick(arr, start, end) {
    if (start >= end) {
        return;
    }

    let low = start;
    let high = end;
    let key = arr[low];
    while (low < high) {
        while (low < high && arr[high] >= key) {
            --high;
        }
        arr[low] = arr[high];

        while (low < high && arr[low] <= key) {
            ++low;
        }
        arr[high] = arr[low];
    }
    arr[low] = key;

    sortQuick(arr, start, low - 1);
    sortQuick(arr, low + 1, end);
}

# 快排 单边扫描法
def qsort(arr: List[int]):
    if not arr or len(arr) <= 1:
        return
    _qsort_c(arr, 0, len(arr) - 1)

def _qsort_c(arr, start, end):
    if start >= end:
        return
    k = _qpartition(arr, start, end)
    _qsort_c(arr, start, k-1)
    _qsort_c(arr, k+1, end)

def _swap(arr, i, j):
    tmp = arr[i]
    arr[i] = arr[j]
    arr[j] = tmp

def _qpartition(arr, start, end):
    pivot = arr[end]
    i = start
    for j in range(start, end):
        if arr[j] < pivot:
            # swap arr[i] with arr[j]
            _swap(arr, i, j)
            i += 1
    _swap(arr, i, end)
    return i

# 利用快排原理 查找数组中第k大元素
def findK(arr: List[int], k):
    return _kvalue(arr, 0, len(arr) - 1, k)

def _kvalue(arr, start, end, k):
    if start >= end:
        return None
    pivot = _qpartition(arr, start, end)
    p = pivot + 1
    if p == k:
        return arr[pivot]
    elif p > k:
        return _kvalue(arr, start, pivot - 1, k)
    else:
        return _kvalue(arr, pivot + 1, end, k)