js常见排序算法

常见的有冒泡排序、选择排序、归并排序、快排、希尔排序、插入排序等 等 

　

var arr=[1,2,3,6,5,4,7,9,8];
        /*冒泡排序*/
        /*相当于是对数组进行循环，相邻的两个进行比较，如果后面的比前面的小，调换位置，始初保持两个数后面的是值较大的，这样排到最后，最大的值会被调换至末尾，依次类推，完成排序*/
        function bubbleSrot(arr) {
            for(var i=0;i<arr.length;i++){
                for(var j=0;j<arr.length-1;j++){ /*这里的lenght-1是设置把排序进行到第几位，因为最后一位已经确定，所以省略最后一个*/
                    if( arr[j+1] < arr[j]){
                        temp = arr[j+1];
                        arr[j+1] = arr[j];
                        arr[j] = temp;
                    }
                }
            }
            return arr;
        }
//        console.log('bubbleSort: '+bubbleSrot(arr));    /*[1, 2, 3, 4, 5, 6, 7, 8, 9]*/


        /*选择排序*/
        /*相当于是从数组中循环，从循环的范围内找出最小的，与第一个比较，如果比第一个小调换位置，如下面代码中，当i=0的时候，相当于第一次循环，所以在数组的第二个到最后一个范围中选出一个最小的，与第一个比较，进行是否调换 ，依此类推，进行数组排序*/
        function selectionSort (arr){
            var len = arr.length;
            for(var i=0;i<len;i++){
                var min = arr[i];   /*假设第一个值为数组中最小值*/
                var index = i;  /*最小值的下标*/
                for(var j= i+1;j<len;j++){  /*从数组下标为1的值开始比较*/
                    if (arr[j] < min) {     /*比较获取最小值，如果下一个值比min小的话，把值赋给min,并把下标赋值给*/
                        min = arr[j];
                        index = j;
                    }
                }
                if(index != i){     /*如果第范围内第一个值不是最小的，把它与最小的调换位置*/
                    var temp = arr[i];
                    arr[i] = arr[index];
                    arr[index] = temp;
                }
            }
            return arr;
        }
//        console.log('selectionSort:'+selectionSort(arr));   /*[1, 2, 3, 4, 5, 6, 7, 8, 9]*/

        /*归并排序*/
        /*所一个数组分为两个数组，先排好左边，再排好右边，然后把两个合并到一起*/
        function mergeSort(arr,s,e){
            if(s>e){   //起始位置大于终点位置，返回空数组
                return [];
            }else if(s==e){
                return [arr[s]]; //起始位置等于终点位置，说明数组里只有一个数字，返回只含一个数字的数组
            }

            var mIndex = Math.floor((s+e)/2); //中间位置的Index
            var arrL = mergeSort(arr,s,mIndex); //将左边的数组排序
            var arrR = mergeSort(arr,mIndex+1,e); //将右边的数组排序

            var resultArr = []; //结果数组
            while(arrL.length>0 || arrR.length>0){ //当左右两个数组都不为空时
                if(arrL[0]<arrR[0]){
                    resultArr.push(arrL.shift());
                }else{
                    resultArr.push(arrR.shift());
                }

                if(arrL.length==0){  //当左边的数组为空时
                    resultArr = resultArr.concat(arrR);
                    break;
                }else if(arrR.length==0){
                    resultArr = resultArr.concat(arrL);
                    break;
                }
            }
            return resultArr;
        }

//        console.log(mergeSort(arr,0,arr.length-1));

        /*快速排序*/
        /*从数组中选一个元素作为标准，大于这个数的放到它的右边，小于这个数的放到它的左边，依此类推，直到只剩下一个元素，排序完成*/
        function quickSort (arr) {
            if (arr.length <= 1) {
                return arr;
            }
            var mNumIndex = Math.floor(arr.length/2);  /*设置基数index*/
            var mNum = arr.splice([mNumIndex],1)[0];     /*获取基数值*/
            var left = [];
            var right = [];

            for(var i=0;i<arr.length;i++){
                if(arr[i]<mNum) {
                    left.push(arr[i]);
                } else {
                    right.push(arr[i]);
                }
            }
            return quickSort(left).concat([mNum],quickSort(right));
        }
//        console.log(quickSort(arr));