js实现四大经典排序算法

为了方便测试，这里写了一个创建长度为n的随机数组

function createArr(n) {
    var arr = [];
    while (n--) {
        arr.push(~~(Math.random() * 100));
    }
    return arr;
}

冒泡排序：在要排序的一组数中，从前往后对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。

即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

若排序要求为从小到大，每一次外层循环把最大的数沉在最后一位，内层循环比较数从序列末位减一位。
注意一点，当要排序 N 个数，已经经过 N-1 次遍历后，已经是有序数列

function bubbleSort(arr){
    var len = arr.length,
            i,
            j;
    for(i = 0; i < len - 1; i++){
        for(j = 0; j < len - 1 - i; j++){
            if(a[j] > a[j+1]){
                a[j+1] = [a[j], a[j] = a[j+1]][0];
            }
        }
    }
    return arr;
}

选择排序：每一次外层循环从待排序的数中选出最小（或最大）的一个元素，存放在序列的起始位置，内层循环比较数从序列首位减一位 ，直到全部待排序的数据元素排完。

function selectSort(arr) {
    var len = arr.length,
            i,
            j,
            min;
    for(i = 0 ; i < len - 1; i++){
        min = i;
        for(j = i + 1; j < len ; j++){
            if(arr[j] < arr[min]){
                min = j;
            }
        }
        if(min != i){
            arr[min] ^= arr[i];
            arr[i] ^= arr[min];
            arr[min] ^= arr[i];
        }
    }
    return arr;
}

快速排序： 在排序效率在同为O(N*logN)的几种排序方法中效率较高，基本思想是：快速排序采用的思想是分治思想。快速排序是找出一个元素（理论上可以随便找一个）作为基准(pivot),然后对数组进行分区操作,使基准左边元素的值都不大于基准值,基准右边的元素值 都不小于基准值，如此作为基准的元素调整到排序后的正确位置。左右两边递归快速排序。

一趟快速排序的算法是：

1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；

2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；

3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；

4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；

5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。
第一种实现方法：

 function quickSort(arr){
        if( (arr.length) > 1){
            var key = arr[0],
                    len = arr.length,
                    leftArr = [],
                    rightArr = [];
            for(var i = 1; i < len; i++){
                if(arr[i] <= key){
                    leftArr.push(arr[i]);
                }else {
                    rightArr.push(arr[i]);
                }
            }
            leftArr = quickSort(leftArr);
            rightArr = quickSort(rightArr);
            return leftArr.concat(key,rightArr);
        }else{
            return arr;
        }
    }

第二种实现方法：

 function quickSort(array) {
        function sort(prev, numsize) {
            var nonius = prev;
            var j = numsize - 1;
            var flag = array[prev];
            if ((numsize - prev) > 1) {
                while (nonius < j) {
                    for (; nonius < j; j--) {
                        if (array[j] < flag) {
                            array[nonius++] = array[j]; //a[i] = a[j]; i += 1;
                            break;
                        }
                        ;
                    }
                    for (; nonius < j; nonius++) {
                        if (array[nonius] > flag) {
                            array[j--] = array[nonius];
                            break;
                        }
                    }
                }
                array[nonius] = flag;
                sort(0, nonius);
                sort(nonius + 1, numsize);
            }
        }

        sort(0, array.length);
        return array;
    }

插入排序： 每步将一个待排序的元素,按其排序码大小,插入到前面已经排好序的一组元素的适当位置上,直到全部插入为止。

function insertSort(arr){
    for(var i=1; i<arr.length; i++){
        var tmp = arr[i];
        var key = i - 1;
        while(key>=0&&tmp<arr[key]){
            arr[key+1] = arr[key]
            key--;
        }
        if(key+1 != i){
            arr[key+1] = tmp
        }
    }
    return arr;
}