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

十种常见的排序算法

1.常见算法分类十种常见排序算法一般分为以下几种: (1)非线性时间比较类排序:交换类排序(快速排序和冒泡排序)、插入类排序(简单插入排序和希尔排序)、选择类排序(简单选择排序和堆排序)、归并排序(...
  • a20180825
  • a20180825
  • 2017年08月03日 10:12
  • 10877

6种常见排序算法(java版)

1、排序算法基本概念1.1、什么是排序算法所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。排序算法,就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相...
  • linpeng123l
  • linpeng123l
  • 2016年08月25日 20:25
  • 1388

面试必备:常见排序算法的实现

http://www.unix-center.net/bbs/viewthread.php?tid=17407常见排序算法的实现(一)-插入排序插入排序是最简单最直观的排序算法了,它的依据是:遍历到第...
  • agwujiang
  • agwujiang
  • 2010年08月21日 23:58
  • 7156

各种排序算法--c++实现

#include using namespace std; //堆排序 void FindMaxInHeap(int arr[], int size) { for (int j = ...
  • woailvmengmeng
  • woailvmengmeng
  • 2014年04月10日 15:26
  • 964

常见的几种内排序算法以及实现(C语言)

所有未排序的数组是经过检查合法的 主要的内排序包括冒泡、插入、希尔、堆排序、归并、快速、桶排序等 冒泡排序 冒泡排序应该是排序中最简单的算法了 主要思路如下: 1: 比较相邻的元素。如果第一个比第...
  • mcu_tian
  • mcu_tian
  • 2016年05月18日 18:43
  • 9100

七大常见排序算法总结

插入类排序 直接插入排序 希尔排序 选择类排序 简单选择排序 堆排序 交换类排序 冒泡排序 快速排序 归并类排序 归并排序...
  • lutianfeiml
  • lutianfeiml
  • 2016年07月19日 19:56
  • 5049

【算法】几种常用排序算法

1. 冒泡排序(Bubble Sort) 冒泡排序算法需要遍历几次数组,在每次遍历中,比较 连续相邻 的元素。如果某一对元素是降序,则互换它们的位置;否则,保持不变。冒泡排序法需要遍历 n-1 次数组...
  • Coding_Fox
  • Coding_Fox
  • 2016年01月18日 16:31
  • 1598

常见排序算法的Javascript实现

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

用JavaScript实现十大经典排序算法--冒泡排序

冒泡排序可谓是最经典的排序算法了,它是基于比较的排序算法,时间复杂度为O(n^2),其优点是实现简单,n较小时性能较好。 1)算法原理        相邻的数据进行两两比较,小数放在前面,大数...
  • u010297791
  • u010297791
  • 2016年12月27日 19:39
  • 1681

几种常用排序算法的思路和复杂度对比

1、插入排序——直接插入排序、希尔排序 (1)直接插入排序思路:从第1号元素开始,每个元素依次与前面的元素做比较,小的排前面,这样当比较到最后一 个元素完即完成排序。 (2)希尔排序思路:...
  • Wengwuhua
  • Wengwuhua
  • 2016年05月17日 21:29
  • 344
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:常见排序算法的JavaScript实现
举报原因:
原因补充:

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