疾速排序（update）

在处置惩罚 Sarafi 中 sort 要领题目时，笔者没有斟酌时刻庞杂度的题目，运用 O(n2) 的排序算法举行重写，在现实产物环境中激发不小的机能题目。

浏览 v8 array.js 源码（Array.js）后发明，Chrome 在完成 sort 要领时对小数组（length <= 10）举行插入排序，对大数组举行疾速排序 O(nlogn)，来下降该要领的时刻庞杂度。

疾速排序的中心是不停把原数组做切割，切割成小数组后再对小数组举行雷同的处置惩罚，这是一种典范的分治的算法想象思绪，拔取数组中第一个元素作为基准，可对其举行简朴完成以下：

function QuickSort(arr, func) {
    if (!arr || !arr.length) return [];
    if (arr.length === 1) return arr;
    
    var pivot = arr[0];
    var smallSet = [];
    var bigSet = [];
    for (var i = 1; i < arr.length; i++) {
        if (func(arr[i], pivot) < 0) {
            smallSet.push(arr[i]);
        } else {
            bigSet.push(arr[i]);
        }
    }
    
    return basicSort(smallSet, func).concat([pivot]).concat(basicSort(bigSet, func));
}

上面的算法建立一个新的数组作为计算结果，从空间运用的角度看是不经济的，Javascript 的疾速排序算法中并没有像上面的代码那样建立一个新的数组，而是在原数组的基础上，经由过程交流元素位置完成排序，故而类似于 push、 pop、 splice 这几个要领，sort 要领也是会修正原数组对象的。

function swap(arr, from, to) {
    if (from === to) return;

    let temp = arr[from];
    arr[from] = arr[to];
    arr[to] = temp;
}
 
function QuickSortWithPartition(arr, fn, from, to) {
    from = from === void 0 ? 0 : from;
    to = to === void 0 ? arr.length : to;

    if (from >= to - 1) {
        return arr;
    }

    let pivot = arr[from];
    let smallIndex = from;
    let bigIndex = from + 1;

    for (; bigIndex < to; bigIndex++) {
        if (fn(arr[bigIndex], pivot) < 0) {
            smallIndex++;
            swap(arr, smallIndex, bigIndex);
        }
    }

    swap(arr, smallIndex, from);

    QuickSortWithPartition(arr, fn, from, smallIndex - 1);
    QuickSortWithPartition(arr, fn, smallIndex + 1, to);

    return arr;
}

个中，from 是肇端索引，to 是停止索引，如果这两个参数缺失，则示意处置惩罚全部数组。

因为上面的分区过程当中，大数分区和小数分区都是从左向右增进，实在我们能够斟酌从两侧向中心遍历，如许能有效地削减交流元素的次数。举个例子，如果我们有一个数组 [2, 1, 3, 1, 3, 1, 3]，采纳上面的分区算法一共会遇到三次比基准元素小的状况，所以会发作三次交流；而如果我们换个思绪，把从右往左找到小于基准的元素，和从左往右找到大于基准的元素交流，这个数组只须要交流一次即可完成排序（把第一个3和末了一个1交流）。

function QuickSortWithPartitionOp(arr, fn, from, to) {
    from = from === void 0 ? 0 : from;
    to = to === void 0 ? arr.length : to;

    if (from >= to - 1) {
        return arr;
    }

    let pivot = arr[from];
    let smallEnd = from;
    let bigBegin = to - 1;

    while (smallEnd < bigBegin) {
        while (fn(arr[bigBegin], pivot) >= 0 && smallEnd < bigBegin) {
            bigBegin--;
        }

        while (fn(arr[smallEnd], pivot) <= 0 && smallEnd < bigBegin) {
            smallEnd++;
        }

        if (smallEnd < bigBegin) {
            swap(arr, smallEnd, bigBegin);
        }
    }

    swap(arr, smallEnd, from);

    QuickSortWithPartitionOp(arr, fn, from, smallEnd - 1);
    QuickSortWithPartitionOp(arr, fn, smallEnd + 1, to);

    return arr;
}

疾速排序算法均匀时刻庞杂度是 O(nlogn)，但它的最差状况下时刻庞杂度会增大到 O(n2)，其机能优劣的症结就在于分区是不是合理：如果每次都能均匀分红相称的两个分区，那末只须要 logn 层递归；而如果每次分区都不合理，总有一个分区是空的，则须要 n 层迭代。

关于一个内容随机的数组而言，不太能够涌现最差状况，但一样平常处置惩罚的数组每每并非内容随机的，一种很轻易的处置惩罚方案是不要拔取牢固位置的元素作为基准元素，而是随机从数组里挑出一个元素作为基准元素，如许能够极大几率地防止最差状况，然而这并不等于防止最差状况，特别是在数组很大的时刻，更要求我们更郑重地拔取基准元素。

三数取中（median-of-three）

三数取中法是遴选基准元素的一种经常使用要领：即遴选基准元素时，先把第一个元素、末了一个元素和中心一个元素挑出来，这三个元素中大小在中心的谁人元素就被以为是基准元素。

function getPivot(arr, fn, from, to) {
    let mid = (from + to) >> 1;

    if (fn(arr[from], arr[mid]) < 0) {
        swap(arr, from, mid);
    }

    if (fn(arr[from], arr[to]) > 0) {
        swap(arr, from, to);
    }

    if (fn(arr[to], arr[mid]) < 0) {
        swap(arr, to, mid);
    }

    return arr[from];
}

其他比较典范的取中值手腕包含：

• 一种是均匀距离取一个元素，多个元素取中位数（即多取几个，增添可靠性）
• 一种是对三数取中举行递归运算，先把大数组均匀分红三块，对每一块举行三数取中，会获得三个中值，再对这三个中值取中位数

v8 源码中的基准元素拔取更加庞杂：如果数组长度不凌驾1000，则举行基础的三数取中；如果数组长度凌驾1000，那末 v8 的处置惩罚是撤除首尾的元素，对剩下的元素每隔200摆布挑出一个元素，对这些元素排序，找出中心的谁人，并用这个元素跟原数组首尾两个元素一同举行三数取中。

针对反复元素的处置惩罚（三路分别）

想象一下，一个数组里如果一切元素都相称，基准元素不管怎样选都是一样的，那末在分区的时刻，必定涌现除基准元素外的其他元素都被分到同一个分区的状况，进入最差机能的 case。

那末关于反复元素应当怎样处置惩罚呢？
从机能的角度，如果发明一个元素与基准元素雷同，那末它应当被记录下来，防止后续再举行不必要的比较。

function QuickSortWithPartitionDump(arr, fn, from, to) {
    from = from === void 0 ? 0 : from;
    to = to === void 0 ? arr.length - 1 : to;

    if (from >= to) {
        return arr;
    }

    let pivot = getPivot(arr, fn, from, to);
    let smallEnd = from;
    let bigBegin = to;
    let i = from + 1;

    while (i <= bigBegin) {
        let r = fn(arr[i], pivot);
        if (r < 0) {
            swap(arr, smallEnd++, i++);
        } else if (r > 0) {
            swap(arr, i, bigBegin--);
        } else {
            i += 1;
        }
    }

    QuickSortWithPartitionDump(arr, fn, from, smallEnd - 1);
    QuickSortWithPartitionDump(arr, fn, bigBegin + 1, to);

    return arr;
}

针对小数组的优化

关于小数组，能够运用疾速排序的速率还不如均匀庞杂度更高的插入排序，故而出于削减递归深度的斟酌，数组长度较小时，运用插入排序算法。

function insertSort(arr, fn, from, to) {
    for (let i = from; i < to; i++) {
        for (let j = i + 1; j < to; j++) {
            let t = fn(arr[i], arr[j]);
            let r = (typeof t === 'number' ? t : t ? 1 : 0) > 0;
            if (r) {
                let tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }
    }

    return arr;
}

v8 引擎分外做的优化

疾速排序如果递归太深的话很能够涌现“爆栈”，上面提到的对小数组采纳插入排序算法，以及采纳内省排序算法都能够削减递归深度，不过 v8 引擎中还做了一些不太罕见的优化：每次分区后，v8 引擎会挑选元素少的分区举行递归，而将元素多的分区直接经由过程轮回处置惩罚，无疑能够大大减小递归深度。

v8 引擎没有做的优化

因为疾速排序时刻庞杂度的不稳定性，David Musser 于1997想象了内省排序法（Introsort），这个算法在疾速排序的基础上，监控递归的深度：一旦长度为 n 的数组经由 logn 层递归（疾速排序算法最好状况下的递归层数）还没有完毕的话，就以为此次疾速排序的效力能够不抱负，转而将盈余部份换用其他排序算法，一般运用堆排序算法（Heapsort，最差时刻庞杂度和最优时刻庞杂度均为 O(nlogn)）。

IOS 中 sort 要领的兼容题目

笔者发明 Safari 或许 iPhone 中 sort 要领不见效（差别浏览器完成机制差别），故推断后举行该要领的重写处置惩罚，代码以下：

;(function(w){
    if(/msie|applewebkit.+safari/i.test(w.navigator.userAgent)){
        var _sort = Array.prototype.sort;
        Array.prototype.sort = function(fn){
            if(!!fn && typeof fn === 'function'){
                if(this.length < 2) return this;
                var i = 0, j = i + 1, l = this.length, tmp, r = false, t = 0;
                for(; i < l; i++){
                    for(j = i + 1; j < l; j++){
                        t = fn.call(this, this[i], this[j]);
                        r = (typeof t === 'number' ? t : !!t ? 1 : 0) > 0 ? true : false;
                        if(r){
                            tmp = this[i];
                            this[i] = this[j];
                            this[j] = tmp;
                        }
                    }
                }
                return this;
            } else {
                return _sort.call(this);
            }
        };
    }
})(window);