• js的各种排序算法


    参考链接:

    http://www.cnblogs.com/fredshare/p/3531594.html

    参考链接:待补充。。。。。。

    http://blog.csdn.net/fengyinchao/article/details/52667625

    http://www.cnblogs.com/eniac12/p/5329396.html

    ******************************************************

    http://www.cnblogs.com/xudong-bupt/p/3168618.html

    sort排序的原理:

    数组sort方法的实现:它到底是怎么实现的呢????为什么比较两个数就能实现排序呢?

    js中的sort排序可能会出现越界的行为,放在Angular框架中越界就会出现错误

    Arrays类中的sort()使用的是“经过调优的快速排序法”;

    js中各个排序算法和sort函数的比较

    js中要实现数据排序,其实只需要用sort函数就能很好的满足了,但是我今天想知道他和其他排序算法的区别,比如耗时呀等。测了一组数据如下:

    复制代码
      1 // ---------- 一些排序算法
      2 Sort = {}
      3 Sort.prototype = {
      4       // 利用sort进行排序  
      5        systemSort:function(array){  
      6           return array.sort(function(a, b){  
      7               return a - b;  
      8           });  
      9       },  
     11       // 冒泡排序  
     12       bubbleSort:function(array){  
     13           var i = 0, len = array.length,  
     14               j, d;  
     15           for(; i<len; i++){  
     16               for(j=0; j<len; j++){  
     17                   if(array[i] < array[j]){  
     18                       d = array[j];  
     19                       array[j] = array[i];  
     20                       array[i] = d;  
     21                   }  
     22               }  
     23           }  
     24           return array;  
     25       }, 
     27       // 快速排序  
     28       quickSort:function(array){  
     29           //var array = [8,4,6,2,7,9,3,5,74,5];  
     30           //var array =[0,1,2,44,4,324,5,65,6,6,34,4,5,6,2,43,5,6,62,43,5,1,4,51,56,76,7,7,2,1,45,4,6,7];  
     31           var i = 0;  
     32           var j = array.length - 1;  
     33           var Sort = function(i, j){  
     34               // 结束条件  
     35               if(i == j ){ return };
     36               var key = array[i];  
     37               var tempi = i; // 记录开始位置  
     38               var tempj = j; // 记录结束位置  
     39               
     40               while(j > i){  
     41                   // j <<-------------- 向前查找  
     42                   if(array[j] >= key){  
     43                       j--;  
     44                   }else{  
     45                       array[i] = array[j]  
     46                       //i++ ------------>>向后查找  
     47                       while(j > ++i){  
     48                           if(array[i] > key){  
     49                               array[j] = array[i];  
     50                               break;  
     51                           }  
     52                       }  
     53                   }  
     54               }
     55               // 如果第一个取出的 key 是最小的数  
     56               if(tempi == i){  
     57                   Sort(++i, tempj);  
     58                   return ;  
     59               }
     60               // 最后一个空位留给 key  
     61               array[i] = key;  
     62               // 递归  
     63               Sort(tempi, i);  
     64               Sort(j, tempj);
     65           }  
     66           Sort(i, j);
     67           return array;  
     68       },    
     70       // 插入排序  
     71       insertSort:function(array){  
     72           // http://baike.baidu.com/image/d57e99942da24e5dd21b7080  
     73           // http://baike.baidu.com/view/396887.htm  
     74           // var array = [0,1,2,44,4,324,5,65,6,6,34,4,5,6,2,43,5,6,62,43,5,1,4,51,56,76,7,7,2,1,45,4,6,7];  
     75           var i = 1, j, temp, key, len = array.length;
     76           for(; i < len; i++){  
     77               temp = j = i;  
     78               key = array[j];  
     79               while(--j > -1){  
     80                   if(array[j] > key){  
     81                       array[j+1] = array[j];  
     82                   }else{
     83                       break;
     84                   }
     85               }
     86               array[j+1] = key;  
     87           }
     88           return array;  
     89       },  
     90         
     91       // 希尔排序  
     92       //Jun.array.shellSort(Jun.array.df(10000));  
     93       shellSort:function(array){  
     94           // http://zh.wikipedia.org/zh/%E5%B8%8C%E5%B0%94%E6%8E%92%E5%BA%8F  
     95           // var array = [13,14,94,33,82,25,59,94,65,23,45,27,73,25,39,10];
     96           // var tempArr = [1750, 701, 301, 132, 57, 23, 10, 4, 1];   
     97           // reverse() 在维基上看到这个最优的步长 较小数组  
     98           var tempArr = [1031612713, 217378076, 45806244, 9651787, 2034035, 428481, 90358, 19001, 4025, 836, 182, 34, 9, 1]  
     99               //针对大数组的步长选择  
    100           var i = 0;  
    101           var tempArrLength = tempArr.length;  
    102           var len = array.length;  
    103           var len2 =  parseInt(len/2);  
    104             
    105           for(;i < tempArrLength; i++){  
    106               if(tempArr[i] > len2){  
    107                   continue;  
    108               }
    109               tempSort(tempArr[i]);  
    110           }
    111           // 排序一个步长  
    112           function tempSort(temp){  
    113               //console.log(temp) 使用的步长统计  
    114               var i = 0, j = 0, f, tem, key;  
    115               var tempLen = len%temp > 0 ?  parseInt(len/temp) + 1 : len/temp;          
    117               for(;i < temp; i++){// 依次循环列  
    119                   for(j=1;/*j < tempLen && */temp * j + i < len; j++){
    120                         //依次循环每列的每行  
    121                       tem = f = temp * j + i;  
    122                       key = array[f];     
    124                       while((tem-=temp) >= 0){  
    125                             // 依次向上查找
    126                           if(array[tem] > key){
    127                               array[tem+temp] = array[tem];
    128                           }else{
    129                               break;
    130                           }
    131                       }
    132                       array[tem + temp ] = key;
    133                   }
    134               }
    135           }
    136           return array;
    137       }
    138 }
    139 testArrs = [];
    140 for (var i = 0; i < 5000; i++) {
    141   testArrs.push(Math.random());
    142 };
    143 console.log(+new Date());
    144 Sort.prototype.systemSort(testArrs);
    145 console.log(+new Date());
    146 Sort.prototype.bubbleSort(testArrs);
    147 console.log(+new Date());
    148 Sort.prototype.quickSort(testArrs);
    149 console.log(+new Date());
    150 ss = Sort.prototype.insertSort(testArrs);
    151 //console.log(ss.toString);
    152 console.log(+new Date());
    153 oo = Sort.prototype.shellSort(testArrs);
    154 console.log(+new Date());
    155 //console.log(oo.toString());
    复制代码

    打印的数据如下:

    1390474099605 
    1390474099614 
    1390474099720 
    1390474099759
    1390474099760 
    1390474099761
    可以看出,冒泡排序耗时最高106,耗时最少的是插入排序,希尔排序也不错,sort函数的排序时间9,相比起来和插入排序差别不是很大,所以在js中用sort来实现排序,在要求不是很高的情况下都是ok的
  • 相关阅读:
    Session丢失问题解决方案
    SQL 将txt文件导入sql数据库
    Ajax的应用实例解析
    ViewState与Session
    .net动态创建DataTable
    TSQL查询进阶数据集之间的运算
    【朝夕Net社区技术专刊】Core3.1 WebApi集群实战专题WebApi环境搭建运行发布部署篇
    经典SQL语句大全
    “存储过程”的定义及优点
    搜索关键词
  • 原文地址:https://www.cnblogs.com/zhangzs000/p/6278970.html
Copyright © 2020-2023  润新知