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.         function quickSort(array){
  45.             function sort(prev, numsize){
  46.                 var nonius = prev;
  47.                 var j = numsize -1;
  48.                 var flag = array[prev];
  49.                 if ((numsize - prev) > 1) {
  50.                     while(nonius < j){
  51.                         for(; nonius < j; j--){
  52.                             if (array[j] < flag) {
  53.                                 array[nonius++] = array[j];　//a[i] = a[j]; i += 1;
  54.                                 break;
  55.                             };
  56.                         }
  57.                         for( ; nonius < j; nonius++){
  58.                             if (array[nonius] > flag){
  59.                                 array[j--] = array[nonius];
  60.                                 break;
  61.                             }
  62.                         }
  63.                     }
  64.                     array[nonius] = flag;
  65.                     sort(0, nonius);
  66.                     sort(nonius + 1, numsize);
  67.                 }
  68.             }
  69.             sort(0, array.length);
  70.             return array;
  71.         }
  72.  
  73.          //归并排序法
  74.  
  75.          function mergeSort(arr){   // 自上而下的递归方法
  76.              var  len = arr.length;
  77.              if(len<2){
  78.                  return arr;
  79.              }
  80.  
  81.              var middle = Math.floor(len /2),
  82.                  left = arr.slice(0,middle),
  83.                  right = arr.slice(middle);
  84.  
  85.              return merge(mergeSort(left),mergeSort(right));
  86.          }
  87.          function merge(left,right){
  88.              var result = [];
  89.              while(left.length && right.length){
  90.                  if(left[0] <= right[0]){
  91.                      result.push(left.shift())
  92.                  }else{
  93.                      result.push(right.shift());
  94.                  }
  95.              }
  96.  
  97.              while(left.length){
  98.                  result.push(left.shift());
  99.              }
  100.              while(right.length){
  101.                  result.push(right.shift());
  102.              }
  103.              return result;
  104.          }
  105.          console.log(mergeSort([5,2,9,8,7,3,6,4,0,1]));
  106.  
  107.          //归并排序对数组内对象的属性进行排序
  108.  
  109.          var merge_Sort = (function() {
  110.              // 合并
  111.              var _merge = function(left, right, prop) {
  112.                  var result = [];
  113.  
  114.                  // 对数组内成员的某个属性排序
  115.                  if (prop) {
  116.                      while (left.length && right.length) {
  117.                          if (left[0][prop] <= right[0][prop]) {
  118.                              result.push(left.shift());
  119.                          } else {
  120.                              result.push(right.shift());
  121.                          }
  122.                      }
  123.                  } else {
  124.                      // 数组成员直接排序
  125.                      while (left.length && right.length) {
  126.                          if (left[0] <= right[0]) {
  127.                              result.push(left.shift());
  128.                          } else {
  129.                              result.push(right.shift());
  130.                          }
  131.                      }
  132.                  }
  133.  
  134.                  while (left.length)
  135.                      result.push(left.shift());
  136.  
  137.                  while (right.length)
  138.                      result.push(right.shift());
  139.  
  140.                  return result;
  141.              };
  142.  
  143.              var _mergeSort = function(arr, prop) { // 采用自上而下的递归方法
  144.                  var len = arr.length;
  145.                  if (len < 2) {
  146.                      return arr;
  147.                  }
  148.                  var middle = Math.floor(len / 2),
  149.                          left = arr.slice(0, middle),
  150.                          right = arr.slice(middle);
  151.                  return _merge(_mergeSort(left, prop), _mergeSort(right, prop), prop);
  152.              };
  153.  
  154.              return function(arr, prop, order) {
  155.                  var result = _mergeSort(arr, prop);
  156.                  if (!order || order.toLowerCase() === 'asc') {
  157.                      // 升序
  158.                      return result;
  159.                  } else {
  160.                      // 降序
  161.                      var _ = [];
  162.                      result.forEach(function(item) {
  163.                          _.unshift(item);
  164.                      });
  165.                      return _;
  166.                  }
  167.              };
  168.          })();
  169.          var arr = [{"name":"zhangsan","age":19},{"name":"lisi","age":20},{"name":"wangwu","age":15},{"name":"wangwu","age":14},{"name":"wangwu","age":17}]
  170.         console.log(merge_Sort(arr,"age"));
  171.  
  172.          //插入排序
  173.  
  174.          function insertSort(arr){
  175.              var len =arr.length,preIndex,current;
  176.              for(var i=1;i<len;i++){
  177.                  preIndex = i-1;
  178.                  current = arr[i];
  179.                  while(preIndex >=0 && arr[preIndex] >current){
  180.                      arr[preIndex+1] = arr[preIndex];
  181.                      preIndex--;
  182.                  }
  183.                  arr[preIndex+1] = current;
  184.              }
  185.              return arr;
  186.          }
  187.        console.log(insertSort([5,2,9,8,7,3,6,4,0,1]))
  188.          //时间复杂度来说， 插入，冒泡，选择排序都在  n^2 ，希尔，归并，快速排序
  189.          // 堆排序都在n*log n,  计数排序，桶排序是n+k，基数排序是n*k；
  190.          //作为常用算法，归并要比快速排序稳定。
  191.      </script>
  192.  </body>
  193.  </html>

JavaScript数据结构-2.排序算法的更多相关文章

  1. Java中的数据结构及排序算法

    (明天补充) 主要是3种接口:List Set Map List:ArrayList,LinkedList:顺序表ArrayList,链表LinkedList,堆栈和队列可以使用LinkedList模 ...

  2. javascript 中合并排序算法 详解

    javascript 中合并排序算法 详解 我会通过程序的执行过程来给大家合并排序是如何排序的...  合并排序代码如下: <script type="text/javascript& ...

  3. JavaScript实现各种排序算法

    前言:本文主要是用JavaScript实现数据结构中的各种排序算法,例如:插入排序.希尔排序.合并排序等. 冒泡排序 function bubbleSort(arr) { console.time(& ...

  4. 用javascript实现简单排序算法

    声明:本文为原创文章,如需转载,请注明来源WAxes,谢谢! 本文为楼主自己的学习记录文章,若有不当之处请斧正. 本文主要记录排序算法 [冒泡排序] 感觉这个是最简单的排序算法了.直接引用维基百科里的 ...

  5. python算法与数据结构-选择排序算法(33)

    一.选择排序的介绍 选择排序(Selection sort)是一种简单直观的排序算法.首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素, ...

  6. python算法与数据结构-希尔排序算法(35)

    一.希尔排序的介绍 希尔排序(Shell Sort)是插入排序的一种.也称缩小增量排序,是直接插入排序算法的一种更高效的改进版本.希尔排序是非稳定排序算法. 希尔排序是把记录按下标的一定增量分组,对每 ...

  7. 【Java】 大话数据结构(14) 排序算法(1) （冒泡排序及其优化）

    本文根据<大话数据结构>一书,实现了Java版的冒泡排序. 更多:数据结构与算法合集 基本概念 基本思想:将相邻的元素两两比较,根据大小关系交换位置,直到完成排序. 对n个数组成的无序数列 ...

  8. 【Java】 大话数据结构(15) 排序算法(2) （快速排序及其优化）

    本文根据<大话数据结构>一书,实现了Java版的快速排序. 更多:数据结构与算法合集 基本概念 基本思想:在每轮排序中,选取一个基准元素,其他元素中比基准元素小的排到数列的一边,大的排到数 ...

  9. 【Java】 大话数据结构(16) 排序算法(3) （堆排序）

    本文根据<大话数据结构>一书,实现了Java版的堆排序. 更多:数据结构与算法合集 基本概念 堆排序种的堆指的是数据结构中的堆,而不是内存模型中的堆. 堆:可以看成一棵完全二叉树,每个结点 ...

随机推荐

  1. Python学习-8.Python的循环语句-while语句

    例子: i = 1 while i < 10: print(i) i+=1 else: print('finish') 输出1至9和finish 在while语句中同样支持for语句所支持的co ...

  2. 浏览器缓存和Service Worker

    浏览器缓存和Service Worker @billshooting 2018-05-06 字数 6175 Follow me on Github 标签: BOM 1. 传统的HTTP浏览器缓存策略 ...

  3. 基于Extjs的web表单设计器

    由于这样工作和自身的一些原因很长一段时间没有写过博客了.最近想把自己前面一段时间搞出的一个表单设计器的相关经验或者经历记录下来.分享给大家,也算是对自己前2个月的一个总结回顾吧. 首先介绍一下开发此版 ...

  4. roadflow作为工作流引擎服务中心webapi说明

    将RoadFlow作为工作流引擎服务中心,其它第三方系统如OA,ERP等通过调用RoadFlow对外提供的标准WebApi接口来实现流程发送.退回.查询待办事项.已办事项.查看流转审批过程等操作.实现 ...

  5. iOS Facebook SDK

    iOS 使用 Facebook SDK 可以登录,分享,发布通知(Notifications)等. 首先下载 Facebook SDK.然后在 Facebook Developer 上注册自己的 ap ...

  6. leetcode 74 搜索二维矩阵 java

    题目: 编写一个高效的算法来判断 m x n 矩阵中,是否存在一个目标值.该矩阵具有如下特性: 每行中的整数从左到右按升序排列. 每行的第一个整数大于前一行的最后一个整数. 示例 1: 输入: mat ...

  7. 深入了解java虚拟机（JVM） 第八章 常见的jvm调优策略

    一般来说,jvm的调优策略是没有一种固定的方法,只有依靠我们的知识和经验来对项目中出现的问题进行分析,正如吉德林法则那样当你已经把问题清楚写出来,就已经解决了一半.虽然JVM调优中没有固定的策略,但是 ...

  8. SpringMvc+ajax 实现json格式数据传递

    传JSON对象 前端 function test () { var param = {username : "yitop"}; $.ajax({ timeout : 20000, ...

  9. Utils工具方法集插件详解

    var Utils = function(){}; Utils.text = { stripTags: function (val) { return val.replace(/<\/?[^&g ...

  10. 【vim】简介与基本配置

    vim是一款非常强大的文字编辑软件,是各种类UNIX系统标配的文本编辑工具.相信此文的读者对它应该不会陌生,在这里就不做介绍了. 1.为什么要使用vim 在认识vim之前,我用过好多IDE:Visua ...