快速排序之优化

快速排序的时间复杂度：

平均时间复杂度的情况：O(nlogn)–在每次数组一分为二时近乎平均分配
最差时间复杂度：O(n²)–在数组完全有序的情况下／超大量重复数组时

快速排序的核心思想

快速排序的核心思想是：分治，分而治之，把所有的子问题解决了，主要问题也就得到了解决。
快速排序的原理：在一个数组中，首先选定一个标定元素，然后根据这个标定元素将数组一分为二，一部分（数组中所有元素）小于这个标定元素，一部分（数组中所有元素）大于这个标定元素，然后将标定元素放置到正确位置（也就是下方代码中__partition函数返回的位置），然后分别对分出的数组进行递归排序，直至循环完成。

快速排序的基本算法

/*返回P值，使得arr[l...p-1]<arr[p],arr[p+1...r]>arr[p]*/
function __partition(arr, l, r) {
    var v = arr[l];
    /*arr[l+1...j]<v,arr[j+1...r]>v*/
    var j = l;
    for (var i = l + 1; i <= r; i++) {
        if (arr[i] < v) {
            [arr[i], arr[j + 1]] = [arr[j + 1], arr[i]];
            j++;
        }
    }
    [arr[l], arr[j]] = [arr[j], arr[l]];
    return j;
}

/*对arr[l....r]进行快速排序*/
function __quickSort(arr, l, r) {
    if (l >= r) return;
    var p = __partition(arr, l, r);
    __quickSort(arr, l, p - 1);
    __quickSort(arr, p + 1, r);

}

function quickSort(arr, n) {
    __quickSort(arr, 0, n - 1);
}

快速排序优化（时间优化–插入排序）

/*返回P值，使得arr[l...p-1]<arr[p],arr[p+1...r]>arr[p]*/
function __partition(arr, l, r) {
    var v = arr[l];
    /*arr[l+1...j]<v,arr[j+1...r]>v*/
    var j = l;
    for (var i = l + 1; i <= r; i++) {
        if (arr[i] < v) {
            [arr[i], arr[j + 1]] = [arr[j + 1], arr[i]];
            j++;
        }
    }
    [arr[l], arr[j]] = [arr[j], arr[l]];
    return j;
}

/*对arr[l....r]进行快速排序*/
function __quickSort(arr, l, r) {
    /*当剩余数组较短时，可采用插入排序，本次不对插入排序做过多介绍 */
    if(r-l >= 15){
        insertionSort(arr, l, r);
        return;
    }
    var p = __partition(arr, l, r);
    __quickSort(arr, l, p - 1);
    __quickSort(arr, p + 1, r);

}

function quickSort(arr, n) {
    __quickSort(arr, 0, n - 1);
}

快速排序的优化(解决近乎完全有序的情况)

/*Math.floor(Math.random()*(max-min+1)+min);
    max - 期望的最大值
    min - 期望的最小值*/


function __partition(arr, l, r) {
    //随机数法
    var random = Math.floor(Math.random() * (r - l + 1) + l);
    [arr[l], arr[random]] = [arr[random], arr[l]];

    var v = arr[l];
    var j = l;
    for (var i = l + 1; i <= r; i++) {
        if (arr[i] < v) {
            [arr[i], arr[j + 1]] = [arr[j + 1], arr[i]];
            j++;
        }
    }
    [arr[l], arr[j]] = [arr[j], arr[l]];
    return j;
}

function __quickSort(arr, l, r) {
    if (l >= r) return;
    var p = __partition(arr, l, r);
    __quickSort(arr, l, p - 1);
    __quickSort(arr, p + 1, r);

}

function quickSort2(arr, n) {
    __quickSort(arr, 0, n - 1);
}

快速排序优化（解决大量重复数据）

/*Math.floor(Math.random()*(max-min+1)+min);
    max - 期望的最大值
    min - 期望的最小值*/


function __partition(arr, l, r) {
    if (l >= r) return;
    //随机数法
    var random = Math.floor(Math.random() * (r - l + 1) + l);
    [arr[l], arr[random]] = [arr[random], arr[l]];

    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 (arr[j] > v && j >= l + 1) j--;
        if (i > j) break;
        [arr[i], arr[j]] = [arr[j], arr[i]];
        i++;
        j--;
    }
    [arr[l], arr[j]] = [arr[j], arr[l]];
    return j;

}

function __quickSort(arr, l, r) {
    if (l >= r) return;
    var p = __partition(arr, l, r);
    __quickSort(arr, l, p - 1);
    __quickSort(arr, p + 1, r);

}

function quickSort2(arr, n) {
    __quickSort(arr, 0, n - 1);
}

快速排序优化（典型的三路排序）

function __quickSort3Ways(arr, l, r) {
    if (l >= r) return;
    /*partition*/
    var random = Math.floor(Math.random() * (r - l + 1) + l);
    [arr[l], arr[random]] = [arr[random], arr[l]];

    var v = arr[l];
    var lt = l;  //arr[l+1...lt]<v
    var gt = r + 1;  //arr[gt...r]>v
    var i = l + 1;  //arr[lt+1...i]==v
    while (i < gt) {
        if (arr[i] < v) {
            [arr[i], arr[lt + 1]] = [arr[lt + 1], arr[i]];
            lt++;
            i++;
        } else if (arr[i] > v) {
            [arr[i], arr[gt - 1]] = [arr[gt - 1], arr[i]];
            gt--;
        } else {  //arr[i]==v
            i++;
        }
    }
    [arr[l], arr[lt]] = [arr[lt], arr[l]];
    __quickSort3Ways(arr, l, lt - 1);
    __quickSort3Ways(arr, gt, r);
}

function quickSort3Ways(arr, n) {
    __quickSort3Ways(arr, 0, n - 1);
}