Java 通过二维数组对角循环

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

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 

---

请自便，看看需要循环的索引：

#1 (0,0)               -> a
#2 (1,0)  (0,1)        -> bd
#3 (2,0)  (1,1)  (0,2) -> gec
#4 (2,1)  (1,2)        -> hf
#5 (2,2)               -> i

查看每次迭代中索引的变化，并创建您的算法。没那么难，所以你自己做作业；）

以下是代码：

public void loopDiag(String [][] b) {

        boolean isPrinted  = false;
        for (int i = 0 ; i < b.length ; i++) {
            String temp="";
            int x=i;
            for(int j = 0 ; j < b.length ; j++) {
                int y = j;
                while (x >= 0 && y < b.length) {
                    isPrinted = false;
                    temp+=b[x--][y++];                  
                }
                if(!isPrinted) {
                    System.out.println(temp);
                    isPrinted = true;
                }
            }
        }
    }

public void loopDiag（字符串[][]b）{
布尔值isPrinted=false；
for（int i=0；i=0&&y

仅出于测试目的初始化阵列：

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

    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( "============================" );

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

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

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

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

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

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

---

我编写了以下代码。关键是耗尽从顶部开始的所有对角线，然后移动到从侧面开始的对角线上。我包括了一种方法，它结合了两个角度来穿越西北-东南和东北-西南的对角线，以及独立的方法来穿越各自的角度

public static void main(String[] args){
    int[][] m = {{1,2,3},{4,5,6},{7,8,9},{10,11,12}};
    printDiagonals(m, DiagonalDirection.NEtoSW, new DiagonalVisitor() {     
        public void visit(int x, int y, int[][] m) {
            System.out.println(m[x][y]);
        }
    });
}

public enum DiagonalDirection{
    NWToSE,
    NEtoSW
}

private static abstract class DiagonalVisitor{
    public abstract void visit(int x, int y, int[][] m);
}

public static void printDiagonals(int[][] m, DiagonalDirection d, DiagonalVisitor visitor){

    int xStart = d==DiagonalDirection.NEtoSW ? 0 : m.length-1;
    int yStart = 1;


    while(true){
        int xLoop, yLoop;
        if(xStart>=0 && xStart<m.length){
            xLoop = xStart;
            yLoop = 0;
            xStart++;
        }else if(yStart<m[0].length){
            xLoop = d==DiagonalDirection.NEtoSW ? m.length-1 : 0;
            yLoop = yStart;
            yStart++;
        }else
            break;

        for(;(xLoop<m.length && xLoop>=0)&&yLoop<m[0].length; xLoop=d==DiagonalDirection.NEtoSW ? xLoop-1 : xLoop+1, yLoop++){
            visitor.visit(xLoop, yLoop, m);
        }

    }

}

public static void printDiagonalsNEtoSW(int[][] m, DiagonalVisitor visitor){

    int xStart = 0;
    int yStart = 1;


    while(true){
        int xLoop, yLoop;
        if(xStart<m.length){
            xLoop = xStart;
            yLoop = 0;
            xStart++;
        }else if(yStart<m[0].length){
            xLoop = m.length-1;
            yLoop = yStart;
            yStart++;
        }else
            break;

        for(;xLoop>=0 && yLoop<m[0].length; xLoop--, yLoop++){
            visitor.visit(xLoop, yLoop, m);
        }


    }
}

public static void printDiagonalsNWtoSE(int[][] m, DiagonalVisitor visitor){

    int xStart = m.length-1;
    int yStart = 1;


    while(true){
        int xLoop, yLoop;
        if(xStart>=0){
            xLoop = xStart;
            yLoop = 0;
            xStart--;
        }else if(yStart<m[0].length){
            xLoop = 0;
            yLoop = yStart;
            yStart++;
        }else
            break;

        for(;xLoop<m.length && yLoop<m[0].length; xLoop++, yLoop++){
            visitor.visit(xLoop, yLoop, m);
        }       
    }
}

publicstaticvoidmain（字符串[]args）{
int[]m={{1,2,3}，{4,5,6}，{7,8,9}，{10,11,12}；
printDiagonals（m，DiagonalDirection.NEtoSW，newdiagonalvisitor（）{
公共无效访问（整数x、整数y、整数[][]m）{
System.out.println（m[x][y]）；
}
});
}
公共枚举对角方向{
新托斯，
NEtoSW
}
私有静态抽象类对角访问者{
公开摘要无效访问（int x，int y，int[]m）；
}
公共静态无效打印对角线（int[][]m，对角线方向d，对角线访问者）{
int xStart=d==DiagonalDirection.NEtoSW？0:m.length-1；
int-yStart=1；
while（true）{
intxloop，yLoop；
如果（xStart>=0&&xStart这适用于非方形数组。这很容易理解，但每个对角线调用一次min（）和max（）

int ndiags = width +  height - 1;
System.out.println("---");
for (int diag = 0; diag < ndiags; diag++) {
    int row_stop = Math.max(0,  diag -  width + 1);
    int row_start = Math.min(diag, height - 1);
    for (int row = row_start; row >= row_stop; row--) {
        // on a given diagonal row + col = constant "diag"
        // diag labels the diagonal number
        int col = diag - row;
        System.out.println(col + "," + row);
        relax(col, row);
    }
    System.out.println("---");
}

public void printMatrixDiagonals(int[][] matrix) {

    int c = 0;
    int count = matrix.length + matrix[0].length -1;
    int i = 0, j = 0;
    //There can be at most  m + n -1 diagonals to be printed
    while (c < count) {
        //Start printing diagonals from i and j
        printDiagonal(i, j, matrix);
        if (i < matrix.length -1) {
            //We increment row index until we reach the max number of rows
            i++;
        } else if (j < matrix[0].length - 1) {
            //We are at maximum index of row; so its time to increment col index
            //We increment column index until we reach the max number of columns
            j++;
        }
        c++;
    }
}

宽度=3，高度=2

---
0,0
---
0,1
1,0
---
1,1
2,0
---
2,1
---

宽度=2，高度=3

---
0,0
---
0,1
1,0
---
0,2
1,1
---
1,2
---

正如Alex在这里提到的，您需要查看循环中的索引。
下面是我如何处理这个问题的

Input:         
a b c    ----- (0,0) (0,1) (0,2)
d e f    ----- (1,0) (1,1) (1,2)
g h i    ----- (2,0) (2,1) (2,2)

Output:
a        ----- (0,0)
b d      ----- (0,1) (1,0)
c e g    ----- (0,2) (1,1) (2,0)
f h      ----- (1,2) (2,1)
i        ----- (2,2)

public class PrintDiagonal{

    public static void printDR(String[][] matrix, int rows, int cols){
        for(int c=0; c < cols; c++){
            for(int i=0, j=c; i< rows && j>=0;i++,j--){
                System.out.print(matrix[i][j] +" ");
             }
             System.out.println();
        }

        for(int r =1; r < rows; r++){
            for(int i =r, j= cols -1; i<rows && j>=0; i++,j--){
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }
    public static void main(String[] args){
        String[][] matrix ={
            {"a","b","c"},
            {"d","e","f"},
            {"g","h","i"}
        };

        int rows = matrix.length;
        int columns = matrix[0].length; 
        printDR(matrix ,rows, columns);
    }
}

输入：
ABC-----（0,0）（0,1）（0,2）
d e f-----（1,0）（1,1）（1,2）
GI-----（2,0）（2,1）（2,2）
输出：
a-----（0,0）
bd-----（0,1）（1,0）
例如------（0,2）（1,1）（2,0）
f h-----（1,2）（2,1）
i-----（2,2）
公共类印刷品{
公共静态void printDR（字符串[][]矩阵，整数行，整数列）{
for（int c=0；c=0；i++，j--）{
系统输出打印（矩阵[i][j]+“”）；
}
System.out.println（）；
}
对于（int r=1；r
这与leoflower在这里发布的内容相同。为了更好地理解，我刚刚更改了变量名

级别=表示正在打印的对角线的当前级别。例如：-级别=2表示具有索引（0,2）、（1,1）、（2,0）的对角线元素

currDiagRowIndex=表示正在打印的当前对角线的行索引

void printMatrixDiagonal(int matrix[][], int endRowIndex, int endColIndex){
    for(int level = 0; level < endColIndex; level++){
        for(int currDiagRowIndex = 0, currDiagColIndex = level; currDiagRowIndex < endRowIndex && currDiagColIndex >= 0 ; currDiagRowIndex++, currDiagColIndex--){
            System.out.print(matrix[currDiagRowIndex][currDiagColIndex] + "  ");
        }
        System.out.println();
    }

    for(int level = 1; level < endRowIndex; level++){
        for(int currDiagRowIndex = level, currDiagColIndex = endColIndex-1; currDiagRowIndex < endRowIndex && currDiagColIndex >= 0; currDiagRowIndex++, currDiagColIndex--){
            System.out.print(matrix[currDiagRowIndex][currDiagColIndex]+ "  ");
        }
        System.out.println();
    }
}

currDiagColIndex=表示正在打印的当前对角线的列索引

void printMatrixDiagonal(int matrix[][], int endRowIndex, int endColIndex){
    for(int level = 0; level < endColIndex; level++){
        for(int currDiagRowIndex = 0, currDiagColIndex = level; currDiagRowIndex < endRowIndex && currDiagColIndex >= 0 ; currDiagRowIndex++, currDiagColIndex--){
            System.out.print(matrix[currDiagRowIndex][currDiagColIndex] + "  ");
        }
        System.out.println();
    }

    for(int level = 1; level < endRowIndex; level++){
        for(int currDiagRowIndex = level, currDiagColIndex = endColIndex-1; currDiagRowIndex < endRowIndex && currDiagColIndex >= 0; currDiagRowIndex++, currDiagColIndex--){
            System.out.print(matrix[currDiagRowIndex][currDiagColIndex]+ "  ");
        }
        System.out.println();
    }
}

输出：

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 

1  
2  6  
3  7  11  
4  8  12  16  
5  9  13  17  21  
10  14  18  22  
15  19  23  
20  24  
25  

1 
4 2 
7 5 3 
8 6 
9 

5 5
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

如果我们将其分解为两个子问题，解决方案会容易得多：

找出每一条对角线的起点
给定对角线的起始索引，打印对角线

int ndiags = width +  height - 1;
System.out.println("---");
for (int diag = 0; diag < ndiags; diag++) {
    int row_stop = Math.max(0,  diag -  width + 1);
    int row_start = Math.min(diag, height - 1);
    for (int row = row_start; row >= row_stop; row--) {
        // on a given diagonal row + col = constant "diag"
        // diag labels the diagonal number
        int col = diag - row;
        System.out.println(col + "," + row);
        relax(col, row);
    }
    System.out.println("---");
}

public void printMatrixDiagonals(int[][] matrix) {

    int c = 0;
    int count = matrix.length + matrix[0].length -1;
    int i = 0, j = 0;
    //There can be at most  m + n -1 diagonals to be printed
    while (c < count) {
        //Start printing diagonals from i and j
        printDiagonal(i, j, matrix);
        if (i < matrix.length -1) {
            //We increment row index until we reach the max number of rows
            i++;
        } else if (j < matrix[0].length - 1) {
            //We are at maximum index of row; so its time to increment col index
            //We increment column index until we reach the max number of columns
            j++;
        }
        c++;
    }
}

public void打印矩阵对角线（int[][]矩阵）{
int c=0；
整数计数=矩阵。长度+矩阵[0]。长度-1；
int i=0，j=0；
//最多可以打印m+n-1条对角线
而（c

打印对角线：请注意，每次开始打印每个对角线时，行的索引应该减少，列的索引应该增加。因此，给定每个对角线的开始索引，我们可以按如下方式打印对角线：

private void打印对角线（int i，int j，int[]m）{
而（i>=0&&j
这是在while循环中打印对角线矩阵的非常直观的方法

将问题概括为整体而不是两部分，并根据空间复杂性进行优化
public void printMatrixDiagonals(int[][] matrix) {

    int c = 0;
    int count = matrix.length + matrix[0].length -1;
    int i = 0, j = 0;
    //There can be at most  m + n -1 diagonals to be printed
    while (c < count) {
        //Start printing diagonals from i and j
        printDiagonal(i, j, matrix);
        if (i < matrix.length -1) {
            //We increment row index until we reach the max number of rows
            i++;
        } else if (j < matrix[0].length - 1) {
            //We are at maximum index of row; so its time to increment col index
            //We increment column index until we reach the max number of columns
            j++;
        }
        c++;
    }
}

private void printDiagonal(int i, int j, int[][] m) {
    while (i >=0 && j< m[0].length ) {
        System.out.print(m[i][j] + " ");
        i--;
        j++;
    }
    System.out.println("");
}

package algorithm;

public class printDiagonaly
{
    public static void main(String[] args)
    {
        int[][] a = new int[][]{{1, 2, 3, 4, 5},
                {6, 7, 8, 9, 10},
                {11, 12, 13, 14, 15},
                {16, 17, 18, 19, 20}};

        int lr = 0;
        int lc = -1;
        int fr = -1;
        int fc = 0;
        int row = a.length - 1;
        int col = a[0].length - 1;

        while (lc < col || fc < col || fr < row || lr < row)
        {
            if (fr < row)
            {
                fr++;
            }
            else
            {
                fc++;
            }

            if (lc < col)
            {
                lc++;
            }
            else
            {
                lr++;
            }

            int tfr = fr;
            int tlr = lr;
            int tlc = lc;
            int tfc = fc;

            while (tfr >= tlr && tfc <= tlc)
            {

                System.out.print(a[tfr][tfc] + " ");
                tfr--;
                tfc++;
            }
            System.out.println("\n");
        }
    }
}

int [][]mat = { {1,2,3},
                {4,5,6},
                {7,8,9},
};

int N=3;

for (int s=0; s<N; s++) {
    for (int i=s; i>-1; i--) {
        System.out.print(mat[i][s-i] + " ");
    }
    System.out.println();
}

for (int s=1; s<N; s++) {
    for (int i=N-1; i>=s; i--) {
        System.out.print(mat[i][s+N-1-i] + " ");
    }
    System.out.println();
}

1 
4 2 
7 5 3 
8 6 
9 

    String ar[][]={{"a","b","c"},{"d","e","f"},{"g","h","i"}};
    int size1=ar.length-1, size2=ar.length;

    for(int i=0; i<ar.length; i++)
    {   
        String a="";        
        for(int j=0, x=ar.length-1-i; j<ar.length-i; j++, x--)
        {
            if((j+x)==size1)
            a=a+ar[x][j];
        }
        size1--;

        System.out.println(a);
        a="";
        for(int j=i+1, x=ar.length-1; j<ar.length; j++, x--)
        {
            if((j+x)==size2)
            a=a+ar[x][j];
        }
        System.out.println(a);
        size2++;
    }

r,c=map(int,input().split())
mat=[[str(ch) for ch in input().split()]for _ in range(r)]
for i in range(r*c-2):
    lis=[]
    for j in range(r):
        for k in range(c):
            if k+j==i:
                lis.append(mat[j][k])
    print(*lis[::-1])

5 5
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