常见排序算法的JavaScript实现

常见排序算法的JavaScript实现

才疏学浅，仅供学习交流~

//测试用例
//var arr=[9,1,5,8,3,7,4,6,2];
var arr=[50,10,90,30,70,40,80,60,20];
var arr1=insertionSort(arr);
//var arr2=banaryInsertionSort(arr);
//var arr3=shellSort(arr);
//var arr4=bubbleSort(arr);
//var arr5=simpleSelectionSort(arr);
//var arr6=heapSort(arr);
//var arr7=mergingSort(arr);
//var arr8=quickSort(arr);
alert(arr);


//下面正式开始排序函数吧~
//1-Insertion Sort -直接插入排序
function insertionSort(array){
    if(array instanceof Array){
        for(var i=1; i<array.length;i++){
            var key=array[i];
            var j=i-1;
            while(j>=0 && array[j]>key){
                array[j+1]=array[j];
                j--;
            }
            array[j+1]=key;
        }
        return array;
    }else{
        alert(array+'is not a type of Array');
    }
}

//2-Banary Insertion Sort -二分插入排序
function banaryInsertionSort(array){
    if(array instanceof Array){
        for(var i=1; i<array.length;i++){
            var key=array[i];
            var left=0;
            var right=i-1;
            while(left<=right){
                var middle=parseInt((left+right)/2);
                if(key<array[middle]){
                    right=middle-1;
                }else{
                    left=middle+1;
                }
            }

            for(var j=i-1;j>=left;j--){
                array[j+1]=array[j];
            }
            array[left]=key;
        }
        return array;
    }else{
        alert(array+'is not a type of Array');
    }
}

//3-Shell Sort-shell排序-直接插入排序的改进
function shellSort(array){  
    if(array instanceof Array){
        var len=array.length;
        var increment=len;      
        do{
            increment=parseInt(increment/3)+1;  
            alert(array);
            for(var i=increment;i<len;i++){
                //当i位上的数比i-increment位上的数大时对两者位置进行交换
                if(array[i]<array[i-increment]){
                    var key=array[i];
                    for(var j=i-increment; j>=0 && key<array[j]; j-=increment){ 
                        array[j+increment]=array[j];    
                    }
                    array[j+increment]=key;
                }
            }
        }
        while(increment>1);
        return array;
    }else{
        alert(array+'is not a type of Array');
    }
}

//4-Bubble Sort-冒泡排序
function bubbleSort(array){
    if(array instanceof Array){
        var len=array.length;
        //标志位flag可以避免数组有序时的多余比较
        var flag=true;
        for(var i=0;i<len && flag;i++){
            flag=false;
            for(var j=len-2; j>=i; j--){
                if(array[j] > array[j+1]){
                    //前一个比后一个小时交换位置
                    var tmp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=tmp;
                    flag=true;
                }
            }
        }
        return array;
    }else{
        alert(array+'is not a type of Array');
    }
}

//5-Simple selection Sort-简单选择排序
function simpleSelectionSort(array){
  if(array instanceof Array){
        var len=array.length;
        for(var i=0; i<len;i++){
            var min=i;
            for(var j=i+1;j<len;j++){
                if(array[min]>array[j]){
                    //更新最小值所在的下标
                    min=j;
                }
            }
            if(min!=i){
                //将最小值与i位的数交换
                var tmp=array[i];
                array[i]=array[min];
                array[min]=tmp;
            }
        }
        return array;
    }else{
        alert(array+'is not a type of Array');
    }
}

/*6-Heap Sort-堆排序
*数组下标从0开始，根节点的左右子树分别对应2*i+1和2*i+2;
*数组下标从1开始，根节点的左右子树分别对应2*i和2*i+1;
*/
function heapSort(array){
  if(array instanceof Array){
        var len=array.length;       
        for(var i=Math.floor(len/2)-1;i>=0;i--){            
            heapAdjust(array,i,len-1);
        }       
        for(var i=len-1;i>1;i--){
            //交换堆顶元素array[0]和最后一位
            var temp=array[i];
            array[i]=array[0];
            array[0]=temp;          
            //调整成大顶堆
            heapAdjust(array,0,i-1);
            alert(i+':'+array);
        }
        return array;
    }else{
        alert(array+'is not a type of Array');
    }
}
//调整array为大顶堆-除了array[s]外，其他都满足大顶堆的定义
//s和m分别为需要调整成为堆的起始位置和结束位置
function heapAdjust(array,s,m){
    var temp=array[s];
    for(var i=2*s+1; i<m; i=2*i+1){
        if(i<m && array[i]<array[i+1]){ //左子树的值比右子树小，将i指向右子树
            i++;
        }
        if(temp>array[i]){
            break;
        }
        array[s]=array[i];
        s=i;   //找到插入的位置
    }
    array[s]=temp;   //插入
}

//7-1-Merging Sort-归并排序递归实现
function mergingSort(array){
    if(array instanceof Array){         
        var n=array.length-1;
        mSort(array,0,n);                       
        return array;
    }else{
        alert(array+'is not a type of Array');
    }
}
//将SR[s..t]归并排序为TR1
function mSort(SR,s,t){     
    if(s<t){
        var m=Math.floor((s+t)/2);              
        mSort(SR,s,m);
        //alert(s+','+m);   
        mSort(SR,m+1,t);
        merge(SR,s,m,t);
    }
}
//将各自有序的SR[s..m]和SR[m+1..n]归并为有序的TR[i..n]
function merge(SR,i,m,n){
    var left=SR.slice(i,m+1); //不包含m+1项
    var right=SR.slice(m+1,n+1); //从m+1到末尾
    var r1=0; //left的遍历变量
    var r2=0;
    var n1=m-i+1;
    var n2=n-m;
    left[n1]=right[n2]=Number.MAX_VALUE; //Number.MAX_VALUE=1.7976931348623157e+308
    for(var k=i;k<=n;k++){
        if(left[r1]<=right[r2]){
            SR[k]=left[r1];
            SR[k];
            r1++;
        }else{
            SR[k]=right[r2];
            r2++;
        }       
    }
}

/*
//7-2-Merging Sort-归并排序非递归实现（此处预留！！！！）
function mergingSort2(array){
  if(array instanceof Array){   
        return array;
    }else{
        alert(array+'is not a type of Array');
    }
}
*/

//8-Quick Sort-快速排序
function quickSort(array){
    if(array instanceof Array){
        if(array.length<=1){
            return array;
        }
        var pivotIndex=Math.floor(array.length/2);
        var pivot=array.splice(pivotIndex,1)[0];
        var left=[];
        var right=[];
        for(var i=0;i<array.length;i++){
            if(array[i]<pivot){
                left.push(array[i]);                
            }else{
                right.push(array[i]);
            }
        }
        return quickSort(left).concat([pivot], quickSort(right));
    }else{
        alert(array+'is not a type of Array');
    }
}