我有一个数组的数组，就像这样:
[
[1,2,3],
[1,2,3],
[1,2,3],
]
我想把它转置得到下面的数组:
[
[1,1,1],
[2,2,2],
[3,3,3],
]
用循环来实现这一点并不难:
function transposeArray(array, arrayLength){
var newArray = [];
for(var i = 0; i < array.length; i++){
newArray.push([]);
};
for(var i = 0; i < array.length; i++){
for(var j = 0; j < arrayLength; j++){
newArray[j].push(array[i][j]);
};
};
return newArray;
}
然而，这看起来很笨重，我觉得应该有更简单的方法来做到这一点。是吗?
当前回答
这个，不仅是一个超级高效的解，而且是一个很短的解。
算法时间复杂度:O(n log n)
const matrix = [
[1,1,1,1],
[2,2,2,2],
[3,3,3,3],
[4,4,4,4]
];
matrix.every((r, i, a) => (
r.every((_, j) => (
j = a.length-j-1,
[ r[j], a[j][i] ] = [ a[j][i], r[j] ],
i < j-1
)),
i < length-2
));
console.log(matrix);
/*
Prints:
[
[1,2,3,4],
[1,2,3,4],
[1,2,3,4],
[1,2,3,4]
]
*/
上面的例子将只进行6次迭代。 对于更大的矩阵，比如100x100，它将进行4900次迭代，这比这里提供的任何其他解决方案快51%。
原理很简单，你只遍历矩阵对角线的上半部分，因为对角线永远不会改变，下对角线的下半部分和上半部分互换了，所以没有理由也遍历它。这样可以节省大量的运行时间，特别是在大型矩阵中。
其他回答
你可以使用underscore.js
_.zip.apply(_, [[1,2,3], [1,2,3], [1,2,3]])
干净的:
[[0, 1], [2, 3], [4, 5]].reduce((prev, next) => next.map((item, i) =>
(prev[i] || []).concat(next[i])
), []); // [[0, 2, 4], [1, 3, 5]]
以前的解决方案在提供空数组时可能会导致失败。
这是一个函数:
function transpose(array) {
return array.reduce((prev, next) => next.map((item, i) =>
(prev[i] || []).concat(next[i])
), []);
}
console.log(transpose([[0, 1], [2, 3], [4, 5]]));
更新。 它可以用展开运算符写得更好:
const transpose = matrix => matrix.reduce(
($, row) => row.map((_, i) => [...($[i] || []), row[i]]),
[]
)
我发现上面的答案要么很难读懂，要么太啰嗦，所以我自己写了一个。我认为这是在线性代数中实现转置的最直观的方法，你不做值交换，而只是把每个元素插入到新矩阵的正确位置:
function transpose(matrix) {
const rows = matrix.length
const cols = matrix[0].length
let grid = []
for (let col = 0; col < cols; col++) {
grid[col] = []
}
for (let row = 0; row < rows; row++) {
for (let col = 0; col < cols; col++) {
grid[col][row] = matrix[row][col]
}
}
return grid
}
编辑:这个答案不会转置矩阵，而是旋转它。我一开始就没有仔细阅读问题:D
顺时针和逆时针旋转:
function rotateCounterClockwise(a){
var n=a.length;
for (var i=0; i<n/2; i++) {
for (var j=i; j<n-i-1; j++) {
var tmp=a[i][j];
a[i][j]=a[j][n-i-1];
a[j][n-i-1]=a[n-i-1][n-j-1];
a[n-i-1][n-j-1]=a[n-j-1][i];
a[n-j-1][i]=tmp;
}
}
return a;
}
function rotateClockwise(a) {
var n=a.length;
for (var i=0; i<n/2; i++) {
for (var j=i; j<n-i-1; j++) {
var tmp=a[i][j];
a[i][j]=a[n-j-1][i];
a[n-j-1][i]=a[n-i-1][n-j-1];
a[n-i-1][n-j-1]=a[j][n-i-1];
a[j][n-i-1]=tmp;
}
}
return a;
}
output = array[0].map((_, colIndex) => array.map(row => row[colIndex]));
Map按顺序为数组中的每个元素调用一次所提供的回调函数，并根据结果构造一个新数组。回调只对数组中已赋值的索引调用;对于已删除或从未赋值的索引，不调用该方法。
callback调用时带有三个参数:元素的值、元素的索引和被遍历的Array对象。(来源)
