假设我们有一个二维数组arr[N][N]，其中N 是constant integer。
假设arr的每个元素都被初始化。
如何使用嵌套的 for 循环打印 arr antidiagonal-wise 的元素？
我的意思是：
arr[0][0] 将被打印出来arr[0][1] 和 arr[1][0] 将被打印出来arr[0][2]、arr[1][1] 和 arr[2][0] 将被打印出来arr[N-1][N-1]。感谢您的宝贵时间！
【问题讨论】：
标签： c++ arrays loops nested 2d
这将适用于一半的矩阵.. 另一半将是相似的：
for (j = 0 ; j < N ; j++)
{
for (i = 0 ; i <= j ; i ++)
{
printf("%d \n",a[i,j-i]);
}
}
【讨论】：
这里是java代码的sn-p，但是算法是一样的
for(int i = 0; i < 10; i++){
for(int j = 0; j <= i; j++){
System.out.print(a[j][i-j] + " ");
}
System.out.println();
}
【讨论】：
您可以注意到，对于任何对角线，[x][y] 和 [x+1][y-1] 给出了 2 个“相邻”元素：也就是说，您向右和向上走对角线。
所以你可以有一个循环来设置对角线的第一个单元格。您只需要遍历y 的所有值，从[0][y] 开始，然后执行此右上步骤（对角线），直到您碰到顶部或右侧。然后你需要做同样的事情，从[0][N-1] 移动到[N-1][N-1] 以覆盖下半场。
代码如下：
for (int _y = 0; _y < N; _y++) {
int x = 0, y = _y;
while (x < N && y >= 0) {
cout << arr[x][y];
x++; y--;
}
cout << endl; // don't forget a newline
}
我将省略后半部分代码，因为它应该大致相同。
【讨论】：
看起来像这样：
for(row = 0; row < N; row++){
for(j = 0; j <= row; j++){
print Array[row - j][j];
}
newline;
}
【讨论】：
对不起所有写“后半部分应该相似”的人......不是。
不管怎样，给你：
// traverse array diagonally
int c, tmp, x;
for (c = N - 1; c > -N; c--) {
tmp = N - abs(c) - 1;
x = tmp;
while (x >= 0) {
if (c >= 0) {
std::cout << arr[x][tmp - x] << ", ";
}
else {
std::cout << arr[N - (tmp - x) - 1][(N-1)-x] << ", ";
}
--x;
}
std::cout << "\n";
}
你需要这个来玩游戏吗？
[edit] 再看一遍，我认为我的答案写得不是很好。这是一个快速浏览：
假设 N 是 3。
我们需要的是对坐标组合的迭代，如下所示：
(0, 0)
(1, 0), (0, 1)
(2, 0), (1, 1), (0, 2)
(2, 1), (1, 2)
(2, 2)
首先是一些占位符：
int c, // a counter, set by the outer loop
tmp, // for intermediate results
x; // the x-index into *arr* (*y* will be defined implicitly)
现在这个外循环
for (c = N - 1; c > -N; c--) {
使 c 迭代 {2, 1, 0, -1, 2}。
下一步
tmp = N - abs(c) - 1;
x = tmp;
将 {2, 1, 0, -1, -2} 变成 {0, 1, 2, 1, 0}，即此步骤所需的输出减一（因此它们可以用作索引）。我们制作了两个副本，tmp 和 x。
现在我们从x倒数到0：
while (x >= 0) {
...
--x;
}
如果我们在 arr 的左上半部分，由 c >= 0 表示，则 x 索引进入 arr需要从对角线开始并下降到零 (0 到 0, 1 到 0 和 2 到 0) ，而 y 索引需要从零开始并上升到对角线 (0 到 0、0 到 1 和 0 到 2):
if (c >= 0) {
std::cout << arr[x][tmp - x] << ", ";
}
一旦我们在右下半部分，x 索引需要从 N 开始并向下到对角线 （2 到 1 和 2 到 2） em>，而 y 索引需要从对角线开始并上升到 N（1 到 2 和 2 到 2）：
else {
std::cout << arr[N - (tmp - x) - 1][(N-1)-x] << ", ";
}
最后我们只需要在每一行的末尾换行：
std::cout << "\n";
萨维？ :-)
【讨论】：
这是矩阵两半的解决方案：
//First half (including middle diagonal)
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
print array[j][i - j];
}
newline;
}
//Second half (excluding middle diagonal)
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < i; j++) {
print array[n - i + j][n - j - 1];
}
newline;
}
【讨论】：
这是我认为有用的一种解决方案 R 是总行数。
void diagonalOrder(int arr[][COLS],int R)
{
for (int i = 0; i < R+COLS-1; i++)
{
int col;
int row;
i<COLS?col=i:col=(COLS-1);
col>i?row=col-i:row=i-col;
for(int j=col;j>=0 ;j--)
{
if(row<R)
cout<<arr[row][j]<<" ";
row++;
}
cout<<endl;
}
}
ie.
const int ROWS = 4;
const int COLS = 3;
int arr[][COLS] = {{ 1, 2, 4 },
{ 3, 5, 7},
{ 6, 8, 10},
{ 9, 11, 12}
};
diagonalOrder(arr,ROWS);
Output
----------
1
2 3
4 5 6
7 8 9
10 11
12
------------------------------------------------------
const int ROWS = 8;
const int COLS = 3;
int arr8[][COLS] = {{ 1, 2, 4 },
{ 3, 5, 7 },
{ 6, 8, 10 },
{ 9, 11, 13 },
{ 12, 14, 16},
{ 15 ,17, 19},
{ 18 ,20, 22},
{ 21, 23, 24}
};
cout<<"\n\n8*3 Matrix"<<endl<<endl;
diagonalOrder(arr8,8);
--------------------------------------------------------------
Output
--------------------------------------------------------------
1
2 3
4 5 6
7 8 9
10 11 12
13 14 15
16 17 18
19 20 21
22 23
24
-----------------------------------------
int arr[][COLS] = {{ 1, 2, 4 ,20},
{ 3, 5, 7,20},
{ 6, 8, 10,20},
{ 9, 11, 12,20}
};
-------------------------------------------------------------
Output
-------------------------------------------------------------
1
2 3
4 5 6
20 7 8 9
20 10 11
20 12
20
You can work with n*n Matrix ..
【讨论】：