zoukankan      html  css  js  c++  java
  • JavaScript数据结构-2.排序算法

      1 <!DOCTYPE html>
      2 <html lang="en">
      3 <head>
      4     <meta charset="UTF-8">
      5     <title>js数据结构相关</title>
      6 </head>
      7 <body>
      8     <script>
      9 
     10         //快速排序法
     11        function quick_sort(arr){
     12            function sort(pre,end) {
     13                var k = arr[pre],i=pre,j=end-1;
     14              if ((end-pre) > 1) {
     15                while (i < j) {
     16                    for (;i<j;j--) {
     17                        if (arr[j] < k) {
     18                            arr[i++] = arr[j];
     19                            break;
     20                        }
     21                    }
     22                    for (; i < j; i++) {
     23                        if (arr[i] > k) {
     24                            arr[j--] = arr[i];
     25                            break;
     26                        }
     27                    }
     28                }
     29 
     30                    arr[i] = k;
     31                    sort(0, i);
     32                    sort(i + 1, end);
     33 
     34             }
     35            }
     36            sort(0,arr.length);
     37            return arr;
     38        }
     39 
     40       console.log(quick_sort([5,2,9,8,7,3,6,4,0,1]));
     41        console.log(quickSort([5,2,9,8,7,3,6,4,0,1]));
     42 
     43 
     44         //  快速排序法
     45        function quickSort(array){
     46            function sort(prev, numsize){
     47                var nonius = prev;
     48                var j = numsize -1;
     49                var flag = array[prev];
     50                if ((numsize - prev) > 1) {
     51                    while(nonius < j){
     52                        for(; nonius < j; j--){
     53                            if (array[j] < flag) {
     54                                array[nonius++] = array[j]; //a[i] = a[j]; i += 1;
     55                                break;
     56                            };
     57                        }
     58                        for( ; nonius < j; nonius++){
     59                            if (array[nonius] > flag){
     60                                array[j--] = array[nonius];
     61                                break;
     62                            }
     63                        }
     64                    }
     65                    array[nonius] = flag;
     66                    sort(0, nonius);
     67                    sort(nonius + 1, numsize);
     68                }
     69            }
     70            sort(0, array.length);
     71            return array;
     72        }
     73 
     74         //归并排序法
     75 
     76         function mergeSort(arr){   // 自上而下的递归方法
     77             var  len = arr.length;
     78             if(len<2){
     79                 return arr;
     80             }
     81 
     82             var middle = Math.floor(len /2),
     83                 left = arr.slice(0,middle),
     84                 right = arr.slice(middle);
     85 
     86             return merge(mergeSort(left),mergeSort(right));
     87         }
     88         function merge(left,right){
     89             var result = [];
     90             while(left.length && right.length){
     91                 if(left[0] <= right[0]){
     92                     result.push(left.shift())
     93                 }else{
     94                     result.push(right.shift());
     95                 }
     96             }
     97 
     98 
     99             while(left.length){
    100                 result.push(left.shift());
    101             }
    102             while(right.length){
    103                 result.push(right.shift());
    104             }
    105             return result;
    106         }
    107         console.log(mergeSort([5,2,9,8,7,3,6,4,0,1]));
    108 
    109 
    110         //归并排序对数组内对象的属性进行排序
    111 
    112         var merge_Sort = (function() {
    113             // 合并
    114             var _merge = function(left, right, prop) {
    115                 var result = [];
    116 
    117                 // 对数组内成员的某个属性排序
    118                 if (prop) {
    119                     while (left.length && right.length) {
    120                         if (left[0][prop] <= right[0][prop]) {
    121                             result.push(left.shift());
    122                         } else {
    123                             result.push(right.shift());
    124                         }
    125                     }
    126                 } else {
    127                     // 数组成员直接排序
    128                     while (left.length && right.length) {
    129                         if (left[0] <= right[0]) {
    130                             result.push(left.shift());
    131                         } else {
    132                             result.push(right.shift());
    133                         }
    134                     }
    135                 }
    136 
    137                 while (left.length)
    138                     result.push(left.shift());
    139 
    140                 while (right.length)
    141                     result.push(right.shift());
    142 
    143                 return result;
    144             };
    145 
    146             var _mergeSort = function(arr, prop) { // 采用自上而下的递归方法
    147                 var len = arr.length;
    148                 if (len < 2) {
    149                     return arr;
    150                 }
    151                 var middle = Math.floor(len / 2),
    152                         left = arr.slice(0, middle),
    153                         right = arr.slice(middle);
    154                 return _merge(_mergeSort(left, prop), _mergeSort(right, prop), prop);
    155             };
    156 
    157             return function(arr, prop, order) {
    158                 var result = _mergeSort(arr, prop);
    159                 if (!order || order.toLowerCase() === 'asc') {
    160                     // 升序
    161                     return result;
    162                 } else {
    163                     // 降序
    164                     var _ = [];
    165                     result.forEach(function(item) {
    166                         _.unshift(item);
    167                     });
    168                     return _;
    169                 }
    170             };
    171         })();
    172         var arr = [{"name":"zhangsan","age":19},{"name":"lisi","age":20},{"name":"wangwu","age":15},{"name":"wangwu","age":14},{"name":"wangwu","age":17}]
    173        console.log(merge_Sort(arr,"age"));
    174 
    175 
    176 
    177         //插入排序
    178 
    179         function insertSort(arr){
    180             var len =arr.length,preIndex,current;
    181             for(var i=1;i<len;i++){
    182                 preIndex = i-1;
    183                 current = arr[i];
    184                 while(preIndex >=0 && arr[preIndex] >current){
    185                     arr[preIndex+1] = arr[preIndex];
    186                     preIndex--;
    187                 }
    188                 arr[preIndex+1] = current;
    189             }
    190             return arr;
    191         }
    192       console.log(insertSort([5,2,9,8,7,3,6,4,0,1]))
    193         //时间复杂度来说, 插入,冒泡,选择排序都在  n^2 ,希尔,归并,快速排序
    194         // 堆排序都在n*log n,  计数排序,桶排序是n+k,基数排序是n*k;
    195         //作为常用算法,归并要比快速排序稳定。
    196     </script>
    197 </body>
    198 </html>
  • 相关阅读:
    创建一个函数,将4行3列矩阵a和3行4列矩阵b的乘积,存储在4行4列矩阵c中。
    c语言中将输入的正整数进行逆向输出。
    SAP财务知识点
    后勤管理的各种单据的文档对象和对应显示TCODE列表
    财务分析常用指标
    关于系统消息定制的tCODE列表
    如何在SAP的Screen中编写List报表
    FISAP 月末结帐步骤和年终结转
    正确地使用SAP的标准对话框函数
    如何从SAP中查找BADI
  • 原文地址:https://www.cnblogs.com/chengyunshen/p/7191863.html
Copyright © 2011-2022 走看看