js分组排序算法, OrderBy

由于项目中需要对数据进行分组排序,类似于sql中 order by column1,column2...。 

实现的关键是 分组排序,第一个column1,排序完成之后,对其分组,然后按照column2 排序, 在分组。 以此类推。

下面给出实现:

/**
       * [orderBy description]
       * @param  {[type]} source [description]
       * @param  {[type]} orders [description]
       * @param  {[type]} type  {asc, desc}  [description]
       * @return {[type]}        [description]
       */
      orderBy(source, orders, type) {
        if (source instanceof Array && orders instanceof Array && orders.length > 0) {

          var sorttype = type || ‘asc‘;
          var results = [];
          var totalSum = {};

          function grouporder(source, orders, totalSum) {

            source.sort(function(a, b) {
              if (sorttype.toUpperCase() == ‘ASC‘) {
                return a[orders[0]] - b[orders[0]];
              } else {
                return b[orders[0]] - a[orders[0]];
              }
            })

            var groupmap = new Map();
            source.forEach((item) => {
              if (groupmap.has(item[orders[0]])) {
                groupmap.get(item[orders[0]]).push(item);
              } else {
                groupmap.set(item[orders[0]], []);
                groupmap.get(item[orders[0]]).push(item);
              }
            })

            orders.shift();

            for (let [key, val] of groupmap) {

              totalSum[key] = {};
              totalSum[key].name = key;
              totalSum[key].value = val.length;
              if (orders.length == 0) {
                results = results.concat(val);
              } else {
                totalSum[key].children = {};
                var orderscopy = orders.concat([]);
                grouporder(val, orderscopy, totalSum[key].children);
              }
            }
          }

          grouporder(source, orders, totalSum);

          return {
            results: results,
            totalSum: totalSum
          };
        } else {
          return source;
        }
      }

调用:

this.orderBy(arr, [‘className‘], ‘desc‘)

测试数据:

[{
          className: ‘一班‘,
          name: ‘张三‘,
          sex: ‘女‘,
          age: 21,
          aihao: ‘足球‘
        }, {
          className: ‘一班‘,
          name: ‘张三33‘,
          sex: ‘女‘,
          age: 21,
          aihao: ‘篮球‘
        }, {
          className: ‘一班‘,
          name: ‘张三44‘,
          sex: ‘女‘,
          age: 21,
          aihao: ‘足球‘
        }, {
          className: ‘一班‘,
          name: ‘张三55‘,
          sex: ‘女‘,
          age: 21,
          aihao: ‘篮球‘
        }, {
          className: ‘一班‘,
          name: ‘张三1‘,
          sex: ‘男‘,
          age: 21,
          aihao: ‘篮球‘
        }, {
          className: ‘一班‘,
          name: ‘张三2‘,
          sex: ‘男‘,
          age: 21,
          aihao: ‘足球‘
        }, {
          className: ‘一班‘,
          name: ‘张三3‘,
          sex: ‘女‘,
          age: 21,
          aihao: ‘足球‘
        },

        {
          className: ‘二班‘,
          name: ‘李四‘,
          sex: ‘女‘,
          age: 22,
          aihao: ‘足球‘
        }, {
          className: ‘一班‘,
          name: ‘李四1‘,
          sex: ‘男‘,
          age: 23,
          aihao: ‘篮球‘
        }, {
          className: ‘二班‘,
          name: ‘李四2‘,
          sex: ‘男‘,
          age: 24,
          aihao: ‘足球‘
        }, {
          className: ‘一班‘,
          name: ‘李四3‘,
          sex: ‘女‘,
          age: 24,
          aihao: ‘足球‘
        }, {
          className: ‘二班‘,
          name: ‘李四4‘,
          sex: ‘女‘,
          age: 26,
          aihao: ‘足球‘
        }, {
          className: ‘一班‘,
          name: ‘李四5‘,
          sex: ‘男‘,
          age: 22,
          aihao: ‘篮球‘
        }, {
          className: ‘二班‘,
          name: ‘李四6‘,
          sex: ‘男‘,
          age: 22,
          aihao: ‘足球‘
        },

      ]
时间: 2024-07-29 07:09:40

js分组排序算法, OrderBy的相关文章

List对象分组排序算法

场景: List里面的对象是订单的节点,比如我们快递的物流状态,这个是需要有序的,所以需要根据订单号进行分组排序. import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.List; import java.util.Map; public class GroupSortTest { publi

js 实现排序算法 -- 归并排序(Merge Sort)

原文: 十大经典排序算法(动图演示) 归并排序 归并排序是建立在归并操作上的一种有效的排序算法.该算法是采用分治法(Divide and Conquer)的一个非常典型的应用.将已有序的子序列合并,得到完全有序的序列:即先使每个子序列有序,再使子序列段间有序.若将两个有序表合并成一个有序表,称为2-路归并. 算法描述 把长度为n的输入序列分成两个长度为n/2的子序列: 对这两个子序列分别采用归并排序: 将两个排序好的子序列合并成一个最终的排序序列. 动图演示 代码实现 function merg

js鸡尾酒排序算法

// 鸡尾酒排序算法 function wineSort(arr) { console.log('鸡尾酒算法第0次:' + arr.join(',')); let len = arr.length; for (let i = 0; i < len / 2; i++) { // 奇数次 let isSort = true; for (let j = i; j < len - 1 - i; j++) { if (arr[j + 1] < arr[j]) { let temp = arr[j

JS 随机排序算法

使用JS编写一个方法 让数组中的元素每次刷新随机排列 法一: var arr =[1,2,3,4]; var t; for(var i = 0;i < arr.length; i++){ var rand = parseInt(Math.random()*arr.length); t = arr[rand]; arr[rand] =arr[i]; arr[i] = t; } console.log(arr); 法二: var arr =[1,2,3,4]; var brr = []; var n

常见排序算法基于JS的实现

一:冒泡排序 1. 原理 a. 从头开始比较相邻的两个待排序元素,如果前面元素大于后面元素,就将二个元素位置互换 b. 这样对序列的第0个元素到n-1个元素进行一次遍历后,最大的一个元素就“沉”到序列的最后位置(第n-1个位置,n为待排序元素个数) c.排除此次排序最后面的那个元素(n=n-1),继续对剩余序列重复前面两步 d. 当(n= n-1)=0时,排序完成 2. 具体实现 以如下待排序序列为例: 到此,第一次冒泡完成,最大值7冒泡到最后面. 然后继续对除最后元素(7)外的序列进行冒泡排序

JS实现常用排序算法—经典的轮子值得再造

关于排序算法的博客何止千千万了,也不多一个轮子,那我就斗胆粗制滥造个轮子吧!下面的排序算法未作说明默认是从小到大排序. 1.快速排序2.归并排序3.冒泡排序4.选择排序(简单选择排序)5.插入排序(直接插入排序)6.希尔排序二分查找 1.快速排序 为什么把快排放在最前面呢,因为传说Chrome中数组的sort方法默认采用的就是快排. 算法思想: (1)在数据集之中,选择一个元素作为"基准"(pivot). (2)所有小于"基准"的元素,都移到"基准&quo

JS 排序算法整理

关于排序算法的问题可以在网上搜到一大堆,但是纯 JS 版比较零散,之前面试的时候特意整理了一遍,附带排序效率比较. //1.冒泡排序 var bubbleSort = function(arr) { for (var i = 0, len = arr.length; i < len - 1; i++) { for (var j = i + 1; j < len; j++) { if (arr[i] > arr[j]) { var temp = arr[i]; arr[i] = arr[j

js排序算法总结——冒泡,快速,选择,插入,希尔,归并

相信排序是任何一个程序猿都会用到的东西,今天简单总结记录下常见的排序算法. 一.冒泡排序 说起冒泡排序,可能每个人都不会陌生,实现思路相当简单明了,就是不停的对数组进行两两比较,将较大(较小)的一项放在前面: 如 var arr = [7, 3, 10, 1, 8, 4, 2, 4, 4, 3] 进行升序排列,排序过程如下 第一次 [3, 7, 1, 8, 4, 2, 4, 4, 3, 10] 第二次 [3, 1, 7, 4, 2, 4, 4, 3, 8, 10] 以此类推 .... 结果 [1

排序算法——选择排序(js语言实现)

选择排序:顾名思义选择,选择排序属于O(N^2)的排序算法,意思就是选择数组中的最小的拿出来放在第一位,然后再剩下的数里面,选择最小的,排在第二位,以此类推. 例如:8  3  4  5  6  2  1  7 第一次:寻找数组中最小的数1,然后和8替换,得到 1 3 4 5 6 2 8 7 第二次:因为1的位置已经确定,所以只需要找剩下数组中最小的就行了,2和3互换得到1 2 4 5 6 3 8 7 第三次:1和2的位置已经确定,就看剩下的数中最小的数,3和4互换,结果是1 2 3 5 6 4