javascript实现数据结构中的基本排序方法

简要介绍：基本排序方法，不外乎为冒泡法排序法，插入排序法，选择排序法，归并排序法和快速排序法。

1.冒泡排序法
原理：比较任何相邻的项，如果第一个比第二个大，则交换它们，元素相步步上移，最大的元素依次沉底。

//来一个冒泡排序
function bobbleSort(myArr){
    var length=myArr.length;
    for(var i=0;i<length;i++){
        for(var j=0;j<length-1;j++){
            if(myArr[j]>myArr[j+1]){
                var temple=myArr[j];
                temple=myArr[j+1];
                myArr[j+1]=myArr[j];
                myArr[j]=temple;                
            }
        }

    }
    return myArr;
}

改进后的冒泡：内循环减去外循环中已经跑过的轮次，就可以闭环内循环中不必要的比较

//改进后的冒泡排序，可以少比较几次,修改length-1-i可以减少比较次数
function upBobbleSort(myArr){
    var length=myArr.length;
    for(var i=0;i<length;i++){
        for(var j=0;j<length-1-i;j++){
            if(myArr[j]>myArr[j+1]){
                var temple=myArr[j+1];
                    myArr[j+1]=myArr[j];
                    myArr[j]=temple;
            }
        }
    }
    return myArr;   
}

2.选择排序法
原理是原址比较的排序，每次循环取到本次的最小值，依次放在首位等

//选择排序法，原理：每次先选择最小的那个放在首部，依次迭代
function selectSort(myArr){
    var length=myArr.length||0;
    for(var i=0;i<length;i++){
        var minIndex=i;
        for(var j=i;j<length;j++){
            if(myArr[j]<myArr[minIndex]){
                var temple=myArr[j];
                myArr[j]=myArr[minIndex];
                myArr[minIndex]=temple;
            }
        }

    }
    return myArr;
}

3.插入排序法
原理：每次排一个数组项，并且依次比较前面已经排好的数组，决定新的数组应该插入的位置

//插入排序法，第一项已经排好序或者前n项已经排好序，新到一项插入即可
function insertionSort(myArr){
    var length=myArr.length||0;
    for(var i=1;i<length;i++){
        var temple=myArr[i],
            j=i;
            while(myArr[j-1]>temple&&j>0){
              myArr[j]=myArr[j-1];
              j--;
            }
            myArr[j]=temple;        
    }
    return myArr;
}

4.归并排序
原理：是一种分治算法，将原始数组分成较小的，接着将小的数组合并成较大的

//分组排序法,归并排序法
function mergeSortRec(myArr){
    var mid=Math.floor(myArr.length/2);
    if(myArr.length==1){
       return myArr;
    }
    var left=myArr.slice(0,mid);
    var right=myArr.slice(mid);
    return merge(mergeSortRec(left),mergeSortRec(right));
}
function merge(left,right){
    var result=[],
        il=0,
        ir=0;
    while(il<left.length&&ir<right.length){
        if(left[il]>right[ir]){
            result.push(right[ir]);
            ir++
        }else{
            result.push(left[il]);
            il++
        }
    }
    while(il<left.length){
        //有一些超过俩俩比较的需要额外的手动添加
        result.push(left[il++]);
    }
    while(ir<right.length){
        result.push(right[ir++]);
    }
    return result;
}

5.快速排序法
（1）选择主元
（2）划分数组，进行左右指针比较
（3）依次循环

//快速排序法
function  quickSort(myArr,left,right){
    //left表示起始的节点，right表示结束的节点~
    var index,
        array=myArr;
    if(array.length>1){
        index=partion(array,left,right);
        if(left<index-1){
            quickSort(array,left,index-1);
        }
        if(index<right){
            quickSort(array,index,right);
        }
        return array;
    }
}
function partion(array,left,right){
    var mid=Math.floor((left+right)/2),
        il=left,
        ir=right;
    while(il<=ir){
         while(array[il]<array[mid]){
             il++
         }
         while(array[ir]>array[mid]){
             ir--;
         }
         //交换
         if(il<=ir){
             var temple;
             temple=array[il];
             array[il]=array[ir];
             array[ir]=temple;
             il++;
             ir--;

         }

     }
     return il;
}

6.补充
排好序的数组，可以通过二分法实现快速的查找（这里我们假定数组已经从小到大的排好序了）
（1）选择数组的中间值
（2）如果中间值是待搜索值，那么结束
（3）如果比待搜索值小，则返回（1）选择左边数组进行搜索
（4）如果比待搜索值大，则返回（1）选择右边数组进行搜索