反向排列数组中的项

如何解决反向排列数组中的项

考虑数组

let myArray = [0,1,2,3,4,5,6,7]

我要这样排序

let reversedPairs = [myArray[6],myArray[7],myArray[4],myArray[5],myArray[2],myArray[3],myArray[0],myArray[1]]
// RESULT [6,7,1]

如何获得结果，而不必像reversePairs那样遍历数组？我有兴趣按它们的索引而不是它们的值对它们进行排序。

谢谢。

解决方法

如果arr.length是偶数（成对的数组），则

const arr = [0,1,2,3,4,5,6,7]

const reversePairs = arr => arr.map((_,i) => arr[arr.length - i - 2 * (1 - i % 2)])

console.log(reversePairs(arr))

,

您可以遍历这些对，交换它们，最后反转结果数组：

let myArray = [0,7];
for(let i = 0; i < myArray.length-1; i+=2){
     let temp = myArray[i];
     myArray[i] = myArray[i+1];
     myArray[i+1] = temp;
}
myArray = myArray.reverse();
console.log(myArray);

,

您可以将整数的一半作为增量，并对其余的升序进行排序。

let values = ['a','b','c','e','f','g','h','i'],result = [...values.keys()]
        .sort((a,b) => (b >> 1) - (a >> 1)  || a - b) // or Math.floor(a / 2)
        .map(i => values[i]);

console.log(...result); // [6,7,1]

,

这种方法不是最有效的，但可读性更高。基本上，我们使用reduce()遍历每个值，如果当前的index % 2 == 0是该对中的第一个值，那么我们将unshift的新数组添加到开头。如果index % 2 == 1，则将值添加到第一个数组。然后我们调用flat()将多个对数组组合为一个。

这不是最有效的，因为我们必须遍历所有内容两次并创建一些中间数组。如果您的值列表过大（数千个或更多值），那么我会进一步使用该方法。如果没有，我会用它，因为它更容易理解。

const input = [0,7];
const output = input
 .reduce((result,value,index) => {
  index % 2 == 0 ? result.unshift([value]) : result[0].push(value);
  return result;
 },[])
 .flat();
 
 console.log(output);

此方法可以在一个循环中用一个数组完成所有操作：

const input = [0,7];
const length = input.length;
const output = input.reduce((result,index) => {
  const reversedIndex = length - index - 1;
  result[reversedIndex % 2 == 0 ? reversedIndex + 1 : reversedIndex - 1] = value;
  return result;
},[]);

console.log(output);

在我看来，这有点难理解，但是它可以工作，因为最终数组的长度将是相同的，因此我们基本上只是获得其反向索引，然后根据其上下移动一个索引。如果它是该对中的第一个或第二个值（index % 2 == 0或index % 2 == 1）。

,

...简单明了，并取决于偶数个数组项...

let myArray = [0,7]

function getReorderedArrayPairWiseFromRight(arr) {
  const itemCount = arr.length;

  let idx = itemCount;
  let list = [];

  while (list.length < itemCount) {
    idx = (idx - 2);
    list = list.concat(arr.slice(idx,(idx + 2)));
  }
  return list;
}

console.log(myArray);
console.log(getReorderedArrayPairWiseFromRight(myArray));

.as-console-wrapper { min-height: 100%!important; top: 0; }

...或基于Array.prototype.reduceRight并且完全不知道任何数组的项目数...

function collectPairWiseFromRight(collector,item,idx,arr) {
  if (((idx % 2) === 0) && (idx < (arr.length - 1))) {

    collector.push(arr[idx]);
    collector.push(arr[idx + 1]);
  }
  return collector;
}

console.log(
  [0,7].reduceRight(collectPairWiseFromRight,[])
);
console.log(
  [0,8].reduceRight(collectPairWiseFromRight,[])
);

console.log(
  [0,6].reduceRight(collectPairWiseFromRight,5].reduceRight(collectPairWiseFromRight,1].reduceRight(collectPairWiseFromRight,[])
);

console.log(
  [0].reduceRight(collectPairWiseFromRight,[])
);
console.log(
  [].reduceRight(collectPairWiseFromRight,[])
);

.as-console-wrapper { min-height: 100%!important; top: 0; }

,

数组可以包含任何内容..顺序将如您所愿！

let myArray = [0,7];
myArray.reverse();
let my2=myArray.map((num,index,myArray)=>
  (index%2===0?[]:[num,myArray[index-1]])
);
console.log(my2.flat());