常见排序算法的JavaScript实现

原创 2016年08月29日 17:53:45

常见排序算法的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');
    }
}
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

常见排序算法的Javascript实现

近日准备实习面试,以下是常见排序算法JS实现,转载备用。原文链接 JavaScript实现排序算法冒泡排序冒泡排序的基本思想是从头遍历要排序的数组,比较相邻两个数,如果前面位置的数大于后面位置的数,那...

几种常见排序算法的JavaScript实现

就JavaScript而言,Array对象有方法sort()可以对数组成员进行排序,默认是字典顺序。自定义排序规则需要给sort()方法提供一个函数。此函数本身有2个参数,表示进行比较的两个元素。如果...

java实现常见的集中排序算法

  • 2013年04月22日 18:20
  • 19KB
  • 下载

常见排序算法的实现与性能比较

  • 2011年03月12日 21:30
  • 16KB
  • 下载

javascript常见排序算法总结

javascript常见排序算法总结   算法是程序的灵魂。虽然在前端的开发环境中排序算法不是很经常用到,但常见的排序算法还是应该要掌握的。我在这里从网上整理了一下常见排序算法的javascript...

常见排序算法C++实现

  • 2017年01月23日 14:33
  • 2KB
  • 下载

JavaScript版几种常见排序算法分享

      Javascript是一种由Netscape的LiveScript发展而来的原型化继承的面向对象的动态类型的区分大小写的客户端脚本语言,主要目的是为了解决服务器端语言,比如Perl,遗留的...

常见八大排序算法JAVA实现

  • 2017年04月19日 22:03
  • 34KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:常见排序算法的JavaScript实现
举报原因:
原因补充:

(最多只允许输入30个字)