从数组创建二维矩阵 (java)
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/2706529/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
Creating a 2d matrix from an array (java)
提问by adam
I'm supposed to write a method that creates a 2d matrix from an array, for instance: ({1, 2, 3, 4}, 3) should return the matrix {{1, 2, 3}, {4}}
我应该编写一个从数组创建二维矩阵的方法，例如： ({1, 2, 3, 4}, 3) 应该返回矩阵 {{1, 2, 3}, {4}}
public class Matrix {
public static int[][]toM(int[] array, int a) {
int[][]matrix = new int [(array.length + a- 1)/ a][a];
for (int i = 0; i < array.length; i++){
int value = array[i];
value = value++;
for (int row = 0; row < (array.length + a- 1)/a; row++) {
for (int col = 0; col < a; col++) {
matrix[row][col]= value++;
}
}
}
return matrix;
}
}
a is the number of elements in each row. how am i supposed to get [[1, 2, 3], [4]] if my input is int[] array = {1,2,3,4} and int n =3? I'm getting [[4, 5, 6], [7, 8, 9]]?
a 是每行中的元素数。如果我的输入是 int[] array = {1,2,3,4} 和 int n =3，我应该如何得到 [[1, 2, 3], [4]] ？我得到 [[4, 5, 6], [7, 8, 9]]？
回答by Marcelo Cantos
Your code is a little too far off base to easily repair. For starters, a three-level nested loop is completely unnecessary; also, you don't fetch array elements by writing value++(maybe you are getting confused with the C convention of using *ptr++to walk an array). Start again from first principles.
您的代码离基础有点太远，无法轻松修复。对于初学者来说，三层嵌套循环是完全没有必要的；此外，您不会通过写入来获取数组元素value++（也许您对*ptr++用于遍历数组的 C 约定感到困惑）。从第一原则重新开始。
I'm assuming this is homework, so I'm not going to just write it for you. But here's the basic outline. The number of result elements depends on the input array rather than the dimensions of the output matrix, so your algorithm should loop over the input elements. For each element, some basic math on its index, i, will tell you where it belongs (rowand col) in the output matrix. Assign array[i]to matrix[row][col].
我假设这是家庭作业，所以我不会只是为你写它。但这是基本轮廓。结果元素的数量取决于输入数组而不是输出矩阵的维度，因此您的算法应该遍历输入元素。对于每个元素，对其索引 的一些基本数学运算i将告诉您它在输出矩阵中属于（row和col）的位置。分配array[i]给matrix[row][col].
For bonus points, note that the last row is often shorter than the other rows. Allocating matrix = new int [...][a]will produce [[1, 2, 3], [4, 0, 0]]instead of the stated requirement. Fix this by allocating just the outer array of arrays — matrix = new int [...][]— and allocating each sub-array individually, making a special case of the last row using modulus arithmetic.
对于奖励积分，请注意最后一行通常比其他行短。分配matrix = new int [...][a]将产生[[1, 2, 3], [4, 0, 0]]代替规定的要求。通过只分配数组的外部数组来解决这个问题matrix = new int [...][]——并单独分配每个子数组，使用模数算法对最后一行进行特殊处理。
回答by Fred Haslam
I think the following is closer to what you have in mind:
我认为以下内容更接近您的想法：
public static int[][] toM2(int[] array, int a) {
int[][] matrix = new int [(array.length + a- 1)/ a][a];
for (int i = 0; i < array.length; i++) matrix[i/a][i%a] = array[i];
return matrix;
}
The line int value = array[i]followed by value++indicate that you are thinking about this problem like a C programmer. The array[i]does not give you a pointer to a value, it just gives you a value.
int value = array[i]后面的行value++表明您正在像 C 程序员一样思考这个问题。Thearray[i]不会给你一个指向值的指针，它只是给你一个值。
So, the key is to take the index and transform it into row and column references:
因此，关键是获取索引并将其转换为行和列引用：
int row = i/a;
int col = i%a;
There is still the problem of the rows all being the same length. With java you don't have to allocate all the rows at the same time. In fact, you can a new array for each row. The following is complicated, but it works:
仍然存在所有行长度相同的问题。使用 java，您不必同时分配所有行。实际上，您可以为每一行创建一个新数组。以下是复杂的，但它的工作原理：
public static int[][] toM3(int[] array, int a) {
int[][] matrix = new int[(array.length + a - 1) / a][];
int rowStart = 0;
for (int i = 0; i < array.length; i++) {
int row = i/a;
if (matrix[ row ] == null) {
matrix[ row ] = new int[ Math.min( a, array.length-rowStart) ];
rowStart += a;
}
matrix[ row ][i % a] = array[i];
}
return matrix;
}
回答by polygenelubricants
I think something like this is a lot more readable:
我认为这样的事情更具可读性：
static int[][] transform(int[] arr, int N) {
int M = (arr.length + N - 1) / N;
int[][] mat = new int[M][];
int start = 0;
for (int r = 0; r < M; r++) {
int L = Math.min(N, arr.length - start);
mat[r] = java.util.Arrays.copyOfRange(arr, start, start + L);
start += L;
}
return mat;
}
Your resulting matrix will be MxN, with the last row possibly having less. It uses Arrays.copyOfRangeinstead of manually allocating and copying rows, and some math to figure out M(how many rows will this matrix have?), and L(how many elements will be on this row?)
您生成的矩阵将是MxN，最后一行可能更少。它使用Arrays.copyOfRange而不是手动分配和复制行，以及一些数学运算来计算M（这个矩阵有多少行？），以及L（这一行有多少元素？）
System.out.println(Arrays.deepToString(
transform(new int[] {1,2,3,4,5,6}, 4)
)); // prints "[[1, 2, 3, 4], [5, 6]]"
