几种典型的排序算法

// 冒泡排序
    function swap(myArr, a, b) {
        var temp = myArr[a];
        myArr[a] = myArr[b];
        myArr[b] = temp;
    }
    function bubbleSort(myArr) {
        var len = myArr.length,
                i, j,stop;
        for (i = 0; i < len; i++) {
            for (j = 0, stop = len - 1 - i; j < stop; j++) {
                if (myArr[j] > myArr[j + 1]) {
                    swap(myArr, myArr[j], myArr[j + 1]);
                }
            }
        }
        return myArr;
    }

    // 选择排序
    function selectionSort(myArr) {
        var len = myArr.length,
                min;
        for (var i = 0; i < len; i++) {
            // 将当前值设为最小值
            min = i;
            // 检查数组其余部分是否更小
            for (var j = i + 1; j < len; j++) {
                if (myArr[j] < myArr[min]) {
                    min = j;
                }
            }

            // 如果当前位置不是最小值，将其替换为最小值
            if (i != min) {
                swap(myArr, i, min);
            }
        }
        return myArr;
    }

    // 插入排序
    function insertionSort(myArr) {
        var len = myArr.length,
                value, // 当前比较的值
                i, // 未排序部分的当前位置
                j; // 已排序部分的当前位置
        for (i = 0; i < len; i++) {
            // 储存当前位置的值
            value = myArr[i];
            // 当已排序部分的当前元素大于value，
            // 就将当前元素后移一位，再将前一位与value比较
            for (j = i - 1; j > -1 && myArr[j] > value; j++) {
                myArr[j + 1] = myArr[j];
            }
            myArr[j + 1] = value;
        }
        return myArr;
    }

    // 合并排序
    function merge(left, right) {
        var result = [],
                il,
                ir;
        while (il < left.length && ir < right.length) {
            if (left[il] < right[ir]) {
                result.push(left[il++]);
            } else {
                result.push(right[ir++]);
            }
        }
        return result.concat(left.slice(il)).concat(right.slice(ir));
    }

    function mergeSort(myArr) {
        if (myArr.length < 2) {return myArr;}

        var middle = Math.floor(myArr.length / 2),
                left = myArr.slice(0, middle),
                right = myArr.slice(middle),
                params = merge(mergeSort(left), mergeSort(right));

        // 在返回的数组头部添加0和数组长度两个元素
        params.unshift(0, myArr.length);

        // 讲原来的数组替换为排序后的数组
        myArr.splice.apply(myArr, params);

        return myArr;
    }

    // 快速排序
    function swapN(myArr, firstIndex, secondIndex) {
        var temp = myArr[firstIndex];
        myArr[firstIndex] = myArr[secondIndex];
        myArr[secondIndex] = temp;
    }

    function patition(myArr, left, right) {
        var pivot = myArr[Math.floor((left + right) / 2)],
                i = left,
                j = right;
        while (i <= j) {
            while (myArr[i] < pivot) {
                i++;
            }
            while (myArr[j] > pivot) {
                j--;
            }
            if (i <= j) {
                swapN(myArr, i, j);
                i++;
                j++;
            }
        }
        return i;
    }

    function quickSort(myArr, left, right) {
        if (myArr.length < 2) return myArr;

        left = (typeof left !== 'number' ? 0 : left);
        right = (typeof right !== 'number' ? myArr.length - 1 : right);

        var index = patition(myArr, left, right);

        if (left < index - 1) {
            quickSort(myArr, left, index - 1);
        }
        if (index < right) {
            quickSort(myArr, index, right);
        }
        return myArr;
    }

摘自阮一峰老师网站。