数组组合排序

最新推荐文章于 2023-09-04 17:41:12 发布
最新推荐文章于 2023-09-04 17:41:12 发布
阅读量1k 收藏 3
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41806099/article/details/106913186
版权

一 目录

不折腾的前端，和咸鱼有什么区别

目录
一 目录
二 前言
三 一维数组排列组合
四 多维数组排列组合
五 参考文献

二 前言

本文会介绍：

  1. 一维数组排列组合

  2. 多维数组排列组合

三 一维数组排列组合

已知存在一个数字类型数组，该数组中的每个数字都不相同，例如：

  • [1, 2, 3]

  • [2, 4, 6]

求该数组中各个数字可能具有的组合，例如：

  • [1, 2, 3]：[ [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1] ]

  • [2, 4, 6]：[ [2, 4, 6], [2, 6, 4], [4, 2, 6], [4, 6, 2], [6, 2, 4], [6, 4, 2] ]

那么我们该怎么求解呢？看代码：

const arrange = (arr) => {
  // 1. 设置结果集
  const result = [];
  
  // 2. 递归
  const ergodic = (res) => {
    // 2.1 循环数组 arr
    for (let i = 0; i < arr.length; i++) {
      // 2.1.1 判断已有的 res 数组中不存在当前元素
      // 并且 res 数组差一位就凑齐 arr 的长度了
      if (!res.includes(arr[i]) && res.length === arr.length - 1) {
        result.push([...res, arr[i]]);
        continue;
      }
      // 2.1.2 如果已有的 res 数组不包含当前元素
      // 则添加进来
      if (!res.includes(arr[i])) {
        ergodic([...res, arr[i]]);
      }
    }
  }
  ergodic([], 0);

  // 3. 返回最终结果
  return result;
};

console.log(arrange([2, 4, 6]));
// [ [2, 4, 6], [2, 6, 4], [4, 2, 6], [4, 6, 2], [6, 2, 4], [6, 4, 2] ]

我们通过递归的形式，就可以获取到一维数组的排列组合，这对小伙伴们来说，应该不是问题。

四 多维数组排列组合

在上面，我们求解了一维数组的排列组合，假如我们需要二维甚至多维数组的排列组合，我们要怎么做呢？

下面 jsliang 逐步给你介绍下~

题目：

现在有一批手机，它有各种信息：

  • 颜色：['白色', '黑色', '金色']

  • 内存大小：['16G', '32G', '64G']

  • 版本：['联通', '移动', '电信']

要求：编写一个算法，实现 颜色 + 内存大小 + 版本的组合，类似于：

  • ['白色', '16G', '联通']

  • ['白色', '32G', '联通']

  • ['黑色', '16G', '电信']

  • ……

请输出所有的组合。

const combine = (arr) => {
  
};

// 后端给出的数据
const colorList = ['白色', '黑色', '金色'];
const sizeList = ['16G', '32G', '64G'];
const versionList = ['联通', '移动', '电信'];

console.log(combine([colorList, sizeList, versionList]));

题解：

首先，我们需要知道的是，我们并不确定数组给出的长度，只知道里面是个二维数组，可能有颜色、内存大小、版本、优惠套餐等内容。

然后，我们据此可以先将基本代码列出来：

const combine = (arr) => {
  // 1. 设置结果集
  const result = [];

  // 2. 遍历收集
  // do something
  
  // 3. 返回结果
  return result;
};

const colorList = ['白色', '黑色', '金色'];
const sizeList = ['16G', '32G', '64G'];
const versionList = ['联通', '移动', '电信'];

console.log(
  combine([
    colorList,
    sizeList,
    versionList,
  ])
);

思路最简单的是暴力无疑，如果我们知道 arr 中具体有多少长度，那么我们可以按照正常的思路编写：

const combine = (arr) => {
  // 1. 设置结果集
  const result = [];

  // 2. 遍历收集
  for (let i = 0; i < arr[0].length; i++) {
    for (let j = 0; j < arr[1].length; j++) {
      for (let k = 0; k < arr[2].length; k++) {
        result.push([arr[0][i], arr[1][j], arr[2][k]]);
      }
    }
  }
  
  // 3. 返回结果
  return result;
};

const colorList = ['白色', '黑色', '金色'];
const sizeList = ['16G', '32G', '64G'];
const versionList = ['联通', '移动', '电信'];

console.log(
  combine([
    colorList,
    sizeList,
    versionList,
  ])
);

这样，我们就通过简单的方法获取到了组合：

[
  [ '白色', '16G', '联通' ], [ '白色', '16G', '移动' ], [ '白色', '16G', '电信' ],
  [ '白色', '32G', '联通' ], [ '白色', '32G', '移动' ], [ '白色', '32G', '电信' ],
  [ '白色', '64G', '联通' ], [ '白色', '64G', '移动' ], [ '白色', '64G', '电信' ],
  [ '黑色', '16G', '联通' ], [ '黑色', '16G', '移动' ], [ '黑色', '16G', '电信' ],
  [ '黑色', '32G', '联通' ], [ '黑色', '32G', '移动' ], [ '黑色', '32G', '电信' ],
  [ '黑色', '64G', '联通' ], [ '黑色', '64G', '移动' ], [ '黑色', '64G', '电信' ],
  [ '金色', '16G', '联通' ], [ '金色', '16G', '移动' ], [ '金色', '16G', '电信' ],
  [ '金色', '32G', '联通' ], [ '金色', '32G', '移动' ], [ '金色', '32G', '电信' ],
  [ '金色', '64G', '联通' ], [ '金色', '64G', '移动' ], [ '金色', '64G', '电信' ],
]

但是，如果我们不确定传入的字段有多少，二维数组的长度有多少呢？就好比：

const combine = (arr) => {

};

const colorList = ['白色', '黑色', '金色'];
const sizeList = ['16G', '32G', '64G'];
const versionList = ['联通', '移动', '电信'];
const setMealList = ['套餐一', '套餐二', '套餐三'];

console.log(
  combine([
    colorList,
    sizeList,
    versionList,
    setMealList,
  ])
);

这时候我们就需要 4 次 for() 循环进行嵌套处理？

如果是 5 个，那就 5 次 for() 循环嵌套处理？

这无疑是令人细思极恐的，那么，有没有法子简化下操作呢？

有的，通过递归：

const combine = (arr) => {
  // 1. 如果是 [] 或者 [colorList] 这种单个的，则直接返回
  if (arr.length < 2) {
    return arr[0];
  } else { // 2. 两两组合得到最终结果
    let tempResult = [];
    for (let i = 0; i < arr[0].length; i++) {
      for (let j = 0; j < arr[1].length; j++) {
        // 2.1 如果是单个 * 单个，则返回两者组合
        if (typeof arr[0][i] === 'string') {
          tempResult.push([arr[0][i], arr[1][j]]);
        } else {
          // 2.2 如果前面已经组合过了，通过 ... 解构数组
          tempResult.push([...arr[0][i], arr[1][j]]);
        }
      }
    }
    // 2.3 重组数组
    arr = [tempResult, ...arr.slice(2)];
    // 2.4 返回最终结果
    return combine(arr);
  }
};

const colorList = ['白色', '黑色', '金色'];
const sizeList = ['16G', '32G', '64G'];
const versionList = ['联通', '移动', '电信'];
const setMealList = ['套餐一', '套餐二', '套餐三'];

console.log(
  combine([
    colorList,
    sizeList,
    versionList,
    setMealList,
  ])
); 

输出：

[
  [ '白色', '16G', '联通', '套餐一' ], [ '白色', '16G', '联通', '套餐二' ], [ '白色', '16G', '联通', '套餐三' ],
  [ '白色', '16G', '移动', '套餐一' ], [ '白色', '16G', '移动', '套餐二' ], [ '白色', '16G', '移动', '套餐三' ],
  [ '白色', '16G', '电信', '套餐一' ], [ '白色', '16G', '电信', '套餐二' ], [ '白色', '16G', '电信', '套餐三' ],
  [ '白色', '32G', '联通', '套餐一' ], [ '白色', '32G', '联通', '套餐二' ], [ '白色', '32G', '联通', '套餐三' ],
  [ '白色', '32G', '移动', '套餐一' ], [ '白色', '32G', '移动', '套餐二' ], [ '白色', '32G', '移动', '套餐三' ],
  [ '白色', '32G', '电信', '套餐一' ], [ '白色', '32G', '电信', '套餐二' ], [ '白色', '32G', '电信', '套餐三' ],
  [ '白色', '64G', '联通', '套餐一' ], [ '白色', '64G', '联通', '套餐二' ], [ '白色', '64G', '联通', '套餐三' ],
  [ '白色', '64G', '移动', '套餐一' ], [ '白色', '64G', '移动', '套餐二' ], [ '白色', '64G', '移动', '套餐三' ],
  [ '白色', '64G', '电信', '套餐一' ], [ '白色', '64G', '电信', '套餐二' ], [ '白色', '64G', '电信', '套餐三' ],
  [ '黑色', '16G', '联通', '套餐一' ], [ '黑色', '16G', '联通', '套餐二' ], [ '黑色', '16G', '联通', '套餐三' ],
  [ '黑色', '16G', '移动', '套餐一' ], [ '黑色', '16G', '移动', '套餐二' ], [ '黑色', '16G', '移动', '套餐三' ],
  [ '黑色', '16G', '电信', '套餐一' ], [ '黑色', '16G', '电信', '套餐二' ], [ '黑色', '16G', '电信', '套餐三' ],
  [ '黑色', '32G', '联通', '套餐一' ], [ '黑色', '32G', '联通', '套餐二' ], [ '黑色', '32G', '联通', '套餐三' ],
  [ '黑色', '32G', '移动', '套餐一' ], [ '黑色', '32G', '移动', '套餐二' ], [ '黑色', '32G', '移动', '套餐三' ],
  [ '黑色', '32G', '电信', '套餐一' ], [ '黑色', '32G', '电信', '套餐二' ], [ '黑色', '32G', '电信', '套餐三' ],
  [ '黑色', '64G', '联通', '套餐一' ], [ '黑色', '64G', '联通', '套餐二' ], [ '黑色', '64G', '联通', '套餐三' ],
  [ '黑色', '64G', '移动', '套餐一' ], [ '黑色', '64G', '移动', '套餐二' ], [ '黑色', '64G', '移动', '套餐三' ],
  [ '黑色', '64G', '电信', '套餐一' ], [ '黑色', '64G', '电信', '套餐二' ], [ '黑色', '64G', '电信', '套餐三' ],
  [ '金色', '16G', '联通', '套餐一' ], [ '金色', '16G', '联通', '套餐二' ], [ '金色', '16G', '联通', '套餐三' ],
  [ '金色', '16G', '移动', '套餐一' ], [ '金色', '16G', '移动', '套餐二' ], [ '金色', '16G', '移动', '套餐三' ],
  [ '金色', '16G', '电信', '套餐一' ], [ '金色', '16G', '电信', '套餐二' ], [ '金色', '16G', '电信', '套餐三' ],
  [ '金色', '32G', '联通', '套餐一' ], [ '金色', '32G', '联通', '套餐二' ], [ '金色', '32G', '联通', '套餐三' ],
  [ '金色', '32G', '移动', '套餐一' ], [ '金色', '32G', '移动', '套餐二' ], [ '金色', '32G', '移动', '套餐三' ],
  [ '金色', '32G', '电信', '套餐一' ], [ '金色', '32G', '电信', '套餐二' ], [ '金色', '32G', '电信', '套餐三' ],
  [ '金色', '64G', '联通', '套餐一' ], [ '金色', '64G', '联通', '套餐二' ], [ '金色', '64G', '联通', '套餐三' ],
  [ '金色', '64G', '移动', '套餐一' ], [ '金色', '64G', '移动', '套餐二' ], [ '金色', '64G', '移动', '套餐三' ],
  [ '金色', '64G', '电信', '套餐一' ], [ '金色', '64G', '电信', '套餐二' ], [ '金色', '64G', '电信', '套餐三' ] ]

以上，通过两两相组的形式，我们可以获取到最终的组合。

当然，jsliang 知道小伙伴们不会满足以此，找了一种更简单的写法：

推入数据的时候需要 result.join(',').split(',')，这点可以优化一下，这里就不逼逼了。

const combine = (arr) => {
  const results = [];
  const ergodic = (index, result = []) => {
    for (let i = 0; i < arr[index].length; i++) {
      result[index] = arr[index][i];
      if (index != arr.length - 1) {
        ergodic(index + 1, result);
      } else {
        results.push(result.join(',').split(','));
      }
    }
  }
  ergodic(0, []);

  return results;
};

const colorList = ['白色', '黑色', '金色'];
const sizeList = ['16G', '32G', '64G'];
const versionList = ['联通', '移动', '电信'];
const setMealList = ['套餐一', '套餐二', '套餐三'];

console.log(
  combine([
    colorList,
    sizeList,
    versionList,
    setMealList,
  ])
);

五 参考文献

  • 【博客园】凌云之翼《多个数组的组合排序算法》

  • 【简书】少苏菇凉《js数组排列组合(收录一种简单的方法)》

  • 【微信公众号】程序员黑叔《又懒得加班了，带你去电商公司写商品中心》

不折腾的前端，和咸鱼有什么区别！

jsliang 会每天更新一道 LeetCode 题解，从而帮助小伙伴们夯实原生 JS 基础，了解与学习算法与数据结构。

浪子神剑 会每天更新面试题，以面试题为驱动来带动大家学习，坚持每天学习与思考，每天进步一点！

扫描上方二维码，关注 jsliang 的公众号（左）和 浪子神剑 的公众号（右），让我们一起折腾！

jsliang 的文档库 由 梁峻荣 采用 知识共享 署名-非商业性使用-相同方式共享 4.0 国际 许可协议进行许可。
基于https://github.com/LiangJunrong/document-library上的作品创作。
本许可协议授权之外的使用权限可以从 https://creativecommons.org/licenses/by-nc-sa/2.5/cn/ 处获得。

JavaScriptLiang
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
将两数组合并成一个数组并排序
05-16
简单 易懂 随机产生两个数组AB，并排序，然后将两数组合并并排序用C输出
数组元素全排列、组合 C语言代码
blackeagleoht的博客
06-19 3858
permutation 排列 combination 组合 一、题目来源 Linux C编程一站式学习课后练习题: https://akaedu.github.io/book/ch08s03.html 定义一个数组，编程打印它的全排列。比如定义： #define N 3 int a[N] = { 1, 2, 3 }; 则运行结果是： $ ./a.out 1 2 3 1 3 2 2 1 3 2 3 1 3 2 1 3 1 2 1 2 3 程序的主要思路是： 把第1个数换到最前面来（本来就在最前
最全排列组合算法详解以及套路总结一文突破
热门推荐
bitcarmanlee的博客
03-07 2万+
1.排列组合问题 排列组合是经典的算法问题，相关的内容中学阶段就学习过。在讲算法实现之前，我们先简单复习一下排列组合的相关定义。 排列，英文名称为Permutation，简称P。假设有一个数组{1, 2, 3, 4, 5}，我们需要将数组中的所有元素进行排序，那么第一个位置，我们可以选择五个数字的任何一个，共有5种选择。第二个位置，可以选择剩余四个数字的任何一个，共有4种选择。第三个位置，可以选择剩余三个数字中的任何一个，共有3种选择。第四个位置，可以选择剩余两个数字中的任何一个，共有2种选择。最后一个位置
数组组合
-Heaven的博客
04-03 1299
（同维）数组组合主要有三种形式：垂直组合，水平组合，深度组合我们先生成两个数组 a,bIn [1]: import numpy as np In [2]: a= np.arange(11,20).reshape(3,3) In [3]: a Out[3]: array([[11, 12, 13], [14, 15, 16], [17, 18, 19]]) In [4...
算法总结 - 数组 - 排列组合
regina14的博客
03-09 1167
Array排列组合 排列组合 排列组合是数组类型题目中的常考题。 31. Next Permutation Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers. If such arrangement is not p...
数组的组合与分割
qq_38177190的博客
07-26 537
一.组合 1.横向组合 （1）np.hstack() [In] a = np.arange(9).reshape(3,-1) a [Out] array([[0, 1, 2], [3, 4, 5], [6, 7, 8]]) [In] b = 2*a b [Out] array([[ 0, 2, 4], [ 6, 8, 10], [12, 14, 16]]) [In] np.hstack((a,b)) [Out] a
汉字数组排序
06-14
汉字排序汉字排序汉字排序汉字排序汉字排序汉字排序汉字排序
易语言文本数组排序集成
07-22
易语言文本数组排序集成源码,文本数组排序集成,显示,快速排序
c语言合并两个已排序数组的示例(c语言数组排序)
01-20
问题：将两个已排序数组合并成一个排序数组 这里先不考虑大数据量的情况(在数据量很大时不知大家有什么好的思路或方法？)，只做简单数组的处理。 简单代码如下： 说明：之所以把merge函数定义成返回数组长度，是因为...
matlab开发-多维数组的合并排序
08-26
matlab开发-多维数组的合并排序。使用合并排序技术对单个或多维数组进行排序。
【递归+回溯】实现数组元素的组合、排列和全排列
累计发表博客60余万字，CSDN 博客专家、Java 领域优质创作者、华为云享专家、阿里云专家博主。专注分享 Java 优质文章，毕设实战项目开发，全网粉丝10W+
01-30 7133
目录 一、数组元素的组合 二、数组元素的全排列 三、数组元素的排列组合 Hello，你好呀，我是灰小猿！一个超会写bug的程序猿！ 最近在做蓝桥杯相关的试题的时候发现对数组元素进行排列组合的使用十分的广泛，而常见的排列组合类型的题目也是数据结构和算法的典型例题，所以今天在这里和大家分享一下我们在平常的开发过程中，常会用到的几种排列组合的类型和解法： 一、数组元素的组合 对于从n个元素的数组arr中取出m个数（不考虑顺序且不重复）放到新数组newarr中的情况，常见的思路是使用递归的思想： 从
＜算法＞求一个数组的所有排列组合
小李子还挺酸的博客
10-12 4248
经常会遇到一些笔试题目，通过求出数组的所有排列组合就可以轻易解答出。今天碰巧看到一个很巧妙的求法，故记录一下 例如给定一个数组[1,2,3]，那么排列组合有如下 [1] [2] [3] [1,2] [1,3] [2,3] [1,2,3] 那么实际上每个排列组合都可以将其对应一个数字 [1] //1 0 0 [2] //0 1 0 [3] //0 0 1 [1,2] //1 1 0 [1,3] // 1 0 1 [2,3] //0 1 1 [1,2,3] //1 1 1 当选取元素时，将其
多个数组的组合排序算法
wu_yan00的博客
06-06 524
内存大小有［'16G','32G','64G'］，版本有［'移动','联通','电信'］，要求写一个算法，实现［［'白色','16G','移动'］, ['白色','16G','联通'] ...］这样的组合，扩张，如果后面还有参数，比如再加一个［'国行','港版'］，不改程序一样可以执行！var arr = [['a', 'b', 'c'], [1, 2, 3], ['x', 'y', 'z'],['手机']];我们的到了前两个的组合结果，依据我们的思路，是要把它和原来数组合并成一个新数组。
多个(N)个数组的的元素组合排序算法,多维数组的排列组合或多个数组之间的排列组合
小石头
04-15 1294
算法代码写法一： // 执行组合排列的函数 function doExchange(array){ var len = arr.length; // 当数组大于等于2个的时候 if(len >= 2){ // 第一个数组的长度 var len1 = arr[0].length; // 第二个数组的长度 ...
详细总结组合排列的十余种算法实现
BoCong-Deng的博客
02-10 2万+
目录 •写在前面 •问题引入 •暴力枚举 循环枚举 递归枚举 回溯枚举 •深度优先搜索 前序遍历 中序遍历 后序遍历 •字典序 •二进制位运算 •带重复数字 •总结 •写在前面 排列组合的问题，如果没有合适的算法去解决，时间复杂度会相当的大，毕竟阶乘的时间复杂度不仅让人头大，也让他计算机欲罢不能，而且我们遇到排列组合的相关问题的概率相当的大，所以非常有必要掌握...
多维数组的全部排列组合方式
a1513049385的博客
04-30 1111
记一次多维数组的全部排列组合方式 <!DOCTYPE html> <html lang="zh"> <head> <meta charset="UTF-8"> <title>Title</title> <link rel="stylesheet" href="https://stackpath.boots...
多维数组的组合与拆分
qq_52209816的博客
08-24 579
垂直方向操作 import numpy as np a = np.arange(1,7).reshape(2,3) b = np.arange(7,13).reshape(2,3) # 垂直方向完成组合操作，生成新数组 c = np.vstack((a,b)) # 垂直方向完成拆分操作，生成两个数组 d,e = np.vsplit(c,2) 水平方向操作 import numpy as np a = np. arange(1,7).reshape(2,3) b = np.arange(7,13).
原来python中多维数组的拼接这么简单
榕城候佳人的博客
09-04 1329
前面再多的维度，都只是增加比它低一维度的向量的个数（5维向量在第1个维度拼接是增加4维向量的个数，在第2个维度拼接是增加3维向量的个数······）5.所以，只需要搞清楚最后2个维度，即行和列即可。
数组排列组合算法汇总
JustDoIT
04-29 1827
数组排列组合算法汇总
c语言拼接数组并排序
最新发布
10-22
C语言拼接数组并排序的基本思路是将两个有序数组合并成一个有序数组。可以使用合并排序的方法，即先在两个数组中各取第一个元素进行比较，将小的元素放入新的数组中，然后再取小的元素所在数组的下一个元素与另一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值