Question

假设我们有一个二维数组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]。

谢谢你的时间！

Answer 1

对于写下“下半场应该相似”的所有人都很抱歉......不是。

无论如何，你走了：

// 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";
}

你是否需要这个游戏或什么？

[编辑]再看一遍，我觉得我的答案写得不是很好。这是一个快速浏览：

让我们假装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} ，这是长度的此步骤所需的输出减去1（因此它们可用作索引）。我们制作了两份副本， tmp 和 x 。

现在我们从 x 倒计时到 0 ：

    while (x >= 0) {
        ...
        --x;
    }

如果我们位于 arr 的左上半部分，由 c＆gt; = 0 表示，x-indices进入 arr 需要从对角线开始并下降到零（0到0,1到0和2到0），而y指数需要从零开始并向上到达对角线< em>（0到0,0到1和0到2）：

        if (c >= 0) {
            std::cout << arr[x][tmp - x] << ", ";
        }

一旦我们在右下角，x-indices需要从 N 开始，然后向下到对角线（2到1和2到2），而y-indices需要从对角线开始，然后上升到 N（1到2和2到2）：

        else {
            std::cout << arr[N - (tmp - x) - 1][(N-1)-x] << ", ";
        }

最后我们只需要在每一行的末尾换行：

    std::cout << "\n";

萨维？： - ）

Answer 2

这将适用于矩阵的一半..另一半将是相似的：

for (j = 0 ; j < N ; j++)
{
   for (i = 0 ; i <= j ; i ++)
   {
      printf("%d \n",a[i,j-i]);
   }
}

Answer 3

您可以注意到，对于任何对角线，[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
}

我将遗漏代码的后半部分，因为它应该大致相同。

Answer 4

这是一段java代码，但算法是相同的

for(int i = 0; i < 10; i++){
    for(int j = 0; j <= i; j++){
        System.out.print(a[j][i-j] + " ");
    }
    System.out.println();
}

Answer 5

看起来像这样：

for(row = 0; row < N; row++){  
   for(j = 0; j <= row; j++){  
      print Array[row - j][j];  
   }  
   newline;  
}

Answer 6

以下是矩阵两半的解决方案：

    //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;
    }

Answer 7

这是一个解决方案，我认为它有帮助 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 ..

C ++：以对角线方式处理2d数组元素

7 个答案: