javascript中数组的重新排序

假设你有一个这样的数组，我想对它重新排序

var myarray = [
    [178, 559, 906, 1252] , [381 , 537 , 937 , 1115] , [346 , 529 , 913 , 1069]
];

我想做的是循环遍历每个数组，在第一个循环中取每个数组的第一个值，然后将每个值推送到一个单独的数组中。第二次循环运行时，取每个数组的第二个值，将它们放入单独的数组中，依此类推。因此，单独的数组如下所示

var myNewArray = [178, 381, 346, 559, 537, 529, 906, 937, 913, 1252, 1115, 1069];

我已经遍历了每个数组并得到了所有的值，但是我无法计算出只针对第一个循环的第一个值、第二个循环的第二个值等的逻辑

var arraylength = myarray.length;

for (var i = 0; i < arraylength; i++ ) {

    console.log(i+1 + " time around");

    var noc = myarray[i].length;

    for (var k = 0; k < noc; k++) {
        var a = myarray[i][k];
        console.log(a);
    };
};

var arrayllength=myarray.length；
对于（变量i=0；i

---

这里有一个

Lodash有一个名为的方法，它可以完成您试图做的事情

---

console.log（u.zip（myarray））；//[[178381346]，[559537529]，[906937913]，[12521151069]。

洛达斯有一个名为的方法，可以完成您正在尝试的操作

---

console.log（u.zip（myarray））；//[[178，381，346]，[559，537，529]，[906，937，913]，[1252，1115，1069]，

或者您可以这样做：

.shift（）

返回

数组的
第一项
，但请注意，此解决方案将
更改原始数组

 var myarray = [
  [178, 559, 906, 1252],
  [381, 537, 937, 1115],
  [346, 529, 913, 1069]
];

var resultArray = [];
var maxlen = Math.max.apply(null, myarray.map(function(i) {
  return i.length; }));
var l = 0;
while (l < maxlen) {
  var s = 0;
  var a = [];
  for (i = 0; i < myarray.length; i++) {
    a.push(myarray[i].shift());
   }
  resultArray.push(a);
  l++;
  s++;  
} 
console.log(resultArray);

var myarray=[
[178, 559, 906, 1252],
[381, 537, 937, 1115],
[346, 529, 913, 1069]
];
var resultArray=[]；
var maxlen=Math.max.apply（null，myarray.map（函数（i））{
返回i.length；}）；
var l=0；
而（l
或者，您可以这样做：
.shift（）
返回
数组的
第一项
，但请注意，此解决方案将
更改原始数组

 var myarray = [
  [178, 559, 906, 1252],
  [381, 537, 937, 1115],
  [346, 529, 913, 1069]
];

var resultArray = [];
var maxlen = Math.max.apply(null, myarray.map(function(i) {
  return i.length; }));
var l = 0;
while (l < maxlen) {
  var s = 0;
  var a = [];
  for (i = 0; i < myarray.length; i++) {
    a.push(myarray[i].shift());
   }
  resultArray.push(a);
  l++;
  s++;  
} 
console.log(resultArray);

var myarray=[
[178, 559, 906, 1252],
[381, 537, 937, 1115],
[346, 529, 913, 1069]
];
var resultArray=[]；
var maxlen=Math.max.apply（null，myarray.map（函数（i））{
返回i.length；}）；
var l=0；
而（l
您不应该在外部循环中迭代
myarray
，而应该在内部循环中迭代每个子数组，相反。这有点棘手，因为外循环迭代子数组，但它们可能有不同的长度。我添加了一个
done
变量来知道在哪里停止

var myNewArray = [];
for(var i=0, done=false; !done; ++i) {
  done = true;
  for(var j=0; j<myarray.length; ++j) {
    if(i < myarray[j].length) {
      done = false;
      myNewArray.push(myarray[j][i]);
    }
  }
}

var myNewArray=[]；
对于（变量i=0，完成=false；！完成；++i）{
完成=正确；
对于（var j=0；j而不是在外部循环中迭代
myarray
，在内部循环中迭代每个子数组，你应该做相反的事情。这有点棘手，因为外部循环迭代子数组，但它们可能有不同的长度。我添加了一个
done
变量来知道在哪里停止

var myNewArray = [];
for(var i=0, done=false; !done; ++i) {
  done = true;
  for(var j=0; j<myarray.length; ++j) {
    if(i < myarray[j].length) {
      done = false;
      myNewArray.push(myarray[j][i]);
    }
  }
}

var myNewArray=[]；
对于（变量i=0，完成=false；！完成；++i）{
完成=正确；
对于（var j=0；j好的

也许这太离谱了，但我有一段漫长的回家之旅，还有一些时间要消磨

你的算法问题围绕着你错过了一个步骤这一事实。
实际上，您需要做的是遍历最长数组的范围。
这意味着您需要创建一个范围（实际范围，或者只知道它的最小/最大界限），该范围从0到所有数组的所有长度的最大值

完成后，您需要遍历该范围，在该范围内，您需要遍历所有数组的列表（循环遍历每个二维数组，每次迭代）。

对于每个数组，检查当前索引中是否有元素。

如果有，请将其添加到新阵列。

第一步（你错过的那一步）几乎就像是在发牌；你有4个人在桌上，但实际上你在外面重复的是52张牌，而不是4个人

根据您所做的工作，它有许多不同的名称。

这可能是一个
zip
a
merge
a
rotation
（虽然rotation并不能真正解释展平，只是洗牌）

因此，不用多说，这里有3种解决方案，它们在这方面都是不同的。

第一个解决方案是更为经典的“JavaScript as Java”实现：


函数findMax（数组）{
var i=0；
var l=数组长度；
var max=0；
var数组=[]；
对于（；imax？array.length:max；
}
返回最大值；
}
函数rotateAndFlatten（数组）{
var FlattedArray=[]；
var maxLength=findMax（数组）；
var内部=0；
var=0；
变量数组；
无功电流值；
对于（；外部<最大长度；外部+=1）{
对于（内部=0；内部

Input:

输出：
好的

也许这太离谱了，但我有一段漫长的回家之旅，还有一些时间要消磨

你的算法问题围绕着你错过了一个步骤这一事实。
实际上，您需要做的是遍历最长数组的范围。
Whi