我编写了以下代码来遍历数组的一半对角线：

String[][] b = [a,b,c]
               [d,e,f]
               [g,h,i];  

public void LoopDiag()
   for (int i = b.length - 1; i > 0; i--) {
       String temp = "";
       for (int j = 0, x = i; x <= b.length - 1; j++, x++) {
          temp = temp+b[x][j];
       }
       System.out.println(temp)
   }


   for (int i = 0; i <= b.length - 1; i++) {
        String temp = "";
        for (int j = 0, y = i; y <= b.length - 1; j++, y++) {
        temp = temp+b[j][y];
        }
        System.out.println(temp);
   }
}

现在它打印对角线，即当前输出：

g dh aei bf c

如何让它打印另一半对角线，即所需的输出：

a db gec hf i 

仅出于测试目的初始化数组：

int dim = 5;
char ch = 'A';
String[][] array = new String[dim][];
for( int i = 0 ; i < dim ; i++ ) {
    array[i] = new String[dim];
    for( int j = 0 ; j < dim ; j++, ch++ ) {
        array[i][j] = "" + ch;
    }
}

输出我们的矩阵：

for( int i = 0 ; i < dim ; i++ ) {
    for( int j = 0 ; j < dim ; j++, ch++ ) {
        System.out.print( array[i][j] + " " );
    }
    System.out.println();
}
System.out.println( "============================" );

Solution

对角线的元素索引有一个规则 - 它们的总和在一条对角线上是恒定的：

变体1

使用两个循环提取所有对角线。

第一个循环提取对角线的上半部分：

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

第二个循环在对角线的下半部分迭代：

for( int k = dim - 2 ; k >= 0 ; k-- ) {
    for( int j = 0 ; j <= k ; j++ ) {
        int i = k - j;
        System.out.print( array[dim - j - 1][dim - i - 1] + " " );
    }
    System.out.println();
}

变体2

使用一个循环提取所有对角线，但是有额外的迭代 and 一张额外支票:

for( int k = 0 ; k < dim * 2 ; k++ ) {
    for( int j = 0 ; j <= k ; j++ ) {
        int i = k - j;
        if( i < dim && j < dim ) {
            System.out.print( array[i][j] + " " );
        }
    }
    System.out.println();
}

输出：

A B C D E 
F G H I J 
K L M N O 
P Q R S T 
U V W X Y 
============================
A 
F B 
K G C 
P L H D 
U Q M I E 
V R N J 
W S O 
X T 
Y 

Update

有关于矩形矩阵的问题（height != width）在评论中。这是矩形矩阵的解决方案：

规则保持不变：来自同一对角线的元素索引之和是恒定的

最小索引之和为0（对于索引为 [0;0] 的矩阵中的第一个元素）

索引的最大总和为宽度 + 高度 - 2（对于矩阵中索引为 [height-1; with-1] 的最后一个元素）

初始化矩形矩阵仅用于测试目的：

int WIDTH = 7;
int HEIGHT = 3;
char ch = 'A';
String[][] array = new String[HEIGHT][];
for( int i = 0 ; i < HEIGHT ; i++ ) {
    array[i] = new String[WIDTH];
    for( int j = 0 ; j < WIDTH ; j++, ch++ ) {
        array[i][j] = "" + ch;
    }
}

打印我们的矩形矩阵：

for( int i = 0 ; i < HEIGHT ; i++ ) {
    for( int j = 0 ; j < WIDTH ; j++, ch++ ) {
        System.out.print( array[i][j] + " " );
    }
    System.out.println();
}
System.out.println( "============================" );

Solution

for( int k = 0 ; k <= WIDTH + HEIGHT - 2; k++ ) {
    for( int j = 0 ; j <= k ; j++ ) {
        int i = k - j;
        if( i < HEIGHT && j < WIDTH ) {
            System.out.print( array[i][j] + " " );
        }
    }
    System.out.println();
}

Output:

A B C D E F G 
H I J K L M N 
O P Q R S T U 
============================
A 
H B 
O I C 
P J D 
Q K E 
R L F 
S M G 
T N 
U