常见排序算法的JS实现

    var array = [5,1,3,6,7,9,3,7,10,2,56,25];
    /*
     *冒泡排序 时间复杂度[O(n^2)]
     *俩俩比较相邻的元素，如果逆序则交换
     */
     
    
    function bubbleSort(arr) {
        //可优化，用flag来判断是否已经排序完成，如果是退出循环
        var len = arr.length-1, temp, i, j;
        for(i = 0;i < len;i++) {
            for(j = 0;j<len;j++){
                if(arr[j]>arr[j+1]) {
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }else{
                    continue;
                }
            }
        }
        return arr;
    }
    
    console.log(bubbleSort(array));

 

 

 

     var array = [5,1,3,6,7,9,3,7,10,2,56,25];
     /*
     *选择排序 时间复杂度[O(n^2)]
     *每次从未排序的序列中找到最小值，记录并最后存放到已排序序列的末尾
     */
    
    
    function selectionSort(arr) {
        var len = arr.length, temp, i, j, _min, minindex;
        for(i = 0;i < len;i++) {
            _min = arr[i];
            minindex = i;
            for(j = i + 1;j < len;j++){
                if(_min > arr[j]) {
                    _min = arr[j];
                    minindex = j;
                }
            }
            arr[minindex] = arr[i];
            arr[i] = _min;
            
        }
        return arr;
    }
    console.log(selectionSort(array));     

 

 

 

    /*
     *插入排序
     *一次选择一个待排序的数据，插入到前边已经排好序的序列中。
     */
     
    var array = [5,1,3,6,7,9,3,7,10,2,56,25];
    //直接插入排序 
    function insertSort(arr) {
        var len = arr.length, temp, i, j;
        for(i = 1; i < len; i++) {
            if(arr[i] < arr[i-1]) {
                temp = arr[i];
                for(j = i - 1;j >= 0 && arr[j] > temp; j--) {
                    arr[j+1] = arr[j];
                }
                arr[j+1] = temp    //将小值插入对应位置            
            }
        }
        return arr;        
    }
    
    console.log(insertSort(array));
    
    //折半插入排序
    
    function insertBinarySort(arr) {
        var len = arr.length, i, j, low, high, mid, temp;
        for(i = 1;i < len; i++) {
            if(arr[i] < arr[i-1]) {
                temp = arr[i];
                low = 0;
                high = i - 1;
                while(low <= high) {
                    mid = Math.ceil((low + high) / 2);
                    if(temp < arr[mid]) {
                        high = mid - 1;
                    }else {
                        low = mid + 1;
                    }
                }
                for(j = i;j > low;j--) {
                    arr[j] = arr[j-1];
                }
                arr[low] = temp;
            }
        } 
        return arr;
    }
    console.log(insertBinarySort(array));

 

 

    /*
     *快速排序
     *通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，
     *然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
     */    
     
    var array = [5,1,3,6,7,9,3,7,10,2,56,25];
    function quickSort(arr){
        function sort(prev, maxsize){
            var nonius = prev, j = maxsize -1, temp = arr[prev];
            if ((maxsize - prev) > 1) { //单个元素数组直接返回
                while(nonius < j){
                    for( ; nonius < j; j--){
                        if (arr[j] < temp) {
                            arr[nonius++] = arr[j];
                            break;
                        };//当找到比基准小的元素时，将小的元素赋值给arr[nonius],而arr[j]本身则由下个for循环找出大的元素填充
                    }
                    for( ; nonius < j; nonius++){
                        if (arr[nonius] > temp){
                            arr[j--] = arr[nonius];
                            break;
                        }//将大的元素填充到arr[j] , j--;
                    }
                }
                arr[nonius] = temp; //最后的空白将基准填充,基准左边全是比基准小的,右边是比自己大的。
                sort(0, nonius);
                sort(nonius + 1, maxsize); //对左右两个数组递归快排
            }
        }
        sort(0, arr.length);
        return arr;
    }
    console.log(quickSort(array));

 

 

　　 /*
     *希尔排序(插入排序的改进,实质上是一种分组插入方法)
     *取一个合适的gap,缩小间隔gap,重复子序列划分和排序，最后gap=1,将所有元素放到一个序列中进行插入排序
     */
     
    var array = [5,1,3,6,7,9,3,7,10,2,56,25];
    function shellSort(arr) {
        var len = arr.length, fraction, i, j, temp, fraction = Math.floor(len / 2);
        for(;fraction > 0;fraction = Math.floor(fraction / 2)){
            for(i = fraction;i < len;i++){
                for(j = i - fraction;j >= 0 && arr[j] > arr[fraction + j];j -= fraction){
                    temp = arr[j];
                    arr[j] = arr[fraction+j];
                    arr[fraction + j] = temp;
                }
            }
        }    
        return arr;
    }
    console.log(shellSort(array));

 

 

    /*
     *归并排序
     *归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）
     *的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序
     */
     
    var array = [5,1,3,6,7,9,3,7,10,2,56,25];
    function merge(left, right){
        var result=[];
        while(left.length > 0 && right.length > 0){
            if(left[0] < right[0]){
                result.push(left.shift());
            }else{
                result.push(right.shift());
            }
        }
        return result.concat(left).concat(right);
    }
    function mergeSort(arr){
        var len = arr.length;
        if(len == 1){
            return arr;
        }
        var middle = Math.floor(len / 2),
            left = arr.slice(0, middle),
            right = arr.slice(middle);
        return merge(mergeSort(left), mergeSort(right));
    }
    
    console.log(mergeSort(array));