快速排序

先看一张图

1，以数组的第一个位置(l)的值(v)作为参考
2，后续的数组的值分两部分，小于v和大于v的，[l+i,j]，[j+1,r)
3，最后，l的值和j的值交换

具体实现代码如下：

window.sortQuick = {
    _partition(arr, l , r) {
        // 在接近有序的数组中效率很低，此处进行了优化
        var ran = Math.round(Math.random()*(r-l))+l;
        sortQuick._swap(arr, l, ran);
        //
        let v = arr[l],
            j = l; // arr[l+1...j] < v ; arr[j+1...i) > v
        for (var i=j+1; i<=r; i++) {
            if (arr[i]<v) {
                j++;
                sortQuick._swap(arr, i, j);
            }
        }
        sortQuick._swap(arr, l, j);
        return j;
    },
    _swap(arr, i, j) {
        var tmp = arr[i];
        arr[i] = arr[j]
        arr[j] = tmp;
    },
    _sort(arr, l ,r) {
        if (l>=r) return;
        var p = sortQuick._partition(arr, l, r);
        sortQuick._sort(arr, l, p-1);
        sortQuick._sort(arr, p+1, r);
    },
    quick({arr}) {
        sortQuick._sort(arr, 0, arr.length-1);
        return arr;
    },
}

双路快速排序，在快速排序的基础上进行了优化，思路还是差不多的，具体看图和代码

window.sortQuick2 = {
    _partition2(arr, l , r) {
        // 在接近有序的数组中效率很低，此处进行了优化
        var ran = Math.round(Math.random()*(r-l))+l;
        sortQuick2._swap(arr, l, ran);
        //
        var v = arr[l];
        // arr[l+1...i)<=v; arr(j...r] >=v
        var i = l+1, j=r;
        while (true) {
            while (i<=r && arr[i]<v) i++;
            while (j>=l+1 && arr[j]>v) j--;
            if (i>j) break;
            sortQuick2._swap(arr, i, j);
            i++;
            j--;
        }
        sortQuick2._swap(arr, l, j);
        return j;
    },
    _swap(arr, i, j) {
        var tmp = arr[i];
        arr[i] = arr[j]
        arr[j] = tmp;
    },
    _sort(arr, l ,r) {
        if (l>=r) return;
        var p = sortQuick2._partition2(arr, l, r);
        sortQuick2._sort(arr, l, p-1);
        sortQuick2._sort(arr, p+1, r);
    },
    quick2({arr}) {
        sortQuick2._sort(arr, 0, arr.length-1);
        return arr;
    },
}

三路快速排序

window.sortQuick3 = {
    _sort(arr, l , r) {
        if (l>=r) return;
        // 在接近有序的数组中效率很低，此处进行了优化
        var ran = Math.round(Math.random()*(r-l))+l;
        sortQuick3._swap(arr, l, ran);
        //
        var v = arr[l];
        var lt = l, // arr[l+1...lt] < v
            gt = r + 1, // arr[gt...r] > v
            i = l + 1;  // arr[lt+1...i] == v
        while (i < gt) {
            if (arr[i] < v) {
                sortQuick3._swap(arr, i, lt+1);
                i++;
                lt++;
            } else if (arr[i] > v) {
                sortQuick3._swap(arr, i, gt-1);
                gt--;
            } else {    // arr[i] == v
                i++;
            }
        }
        sortQuick3._swap(arr, l, lt);
        sortQuick3._sort(arr, l, lt-1);
        sortQuick3._sort(arr, gt, r);
    },
    _swap(arr, i, j) {
        var tmp = arr[i];
        arr[i] = arr[j]
        arr[j] = tmp;
    },
    quick3({arr}) {
        sortQuick3._sort(arr, 0, arr.length-1);
        return arr;
    },
}