斜着打印二维数组-字节面试

给定二维数组，斜着打印出来

1，2，3，4​
5，6，7，8​
9，10，11，12​
------​ 斜着打印二维数组
1，5，2，9，6，3，10，7，4，11，8，12​

思路
第一种方法，利用广度优先遍历的思想，时间复杂度O(n),空间复杂度O(n)，n为二维数组的行数
第二种方法，根据规律，斜着遍历的行，坐标和固定，时间复杂度O(n),空间复杂度O(1)

代码

package com.qunar.flight.userproduct.athena.supercell.core.web.controller;

import org.junit.jupiter.api.Test;

import java.util.LinkedList;
import java.util.Queue;

public class PrintArr {
    public static class Node{
        private int i;
        private int j;
        Node(int i, int j) {
            this.i = i;
            this.j = j;
        }

        public int getJ() {
            return j;
        }

        public void setJ(int j) {
            this.j = j;
        }

        public int getI() {
            return i;
        }

        public void setI(int i) {
            this.i = i;
        }
    }
    //第一种 利用队列 广度优先
    // 遍历队列 出队后 每次保存当前元素的下方元素，如果是队列末尾元素额外把右边元素加入队列
    public static  int[] print(int [][] arr) {
        if(arr == null || arr.length == 0) {
            return null;
        }
        int[] res = new int[arr.length * arr[0].length];
        Queue<Node> queue = new LinkedList<>();
        queue.add(new Node(0,0));
        int index = 0;
        while (!queue.isEmpty()) {
            Queue<Node> temp = new LinkedList<>();
            while(!queue.isEmpty()) {
                //弹出元素
                Node node = queue.poll();
                res[index] = arr[node.getI()][node.getJ()];
                index++;
                //打印下面坐标  添加坐标进入Queue
                if (node.getI()+1 < arr.length) {
                    //有效行数内
                    temp.add(new Node(node.getI()+1, node.getJ()));
                }
                //如果是最后一个元素 则添加右边坐标进入Queue
                if(queue.isEmpty()) {
                    if (node.getJ()+1 < arr[0].length) {
                        temp.add(new Node(node.getI(), node.getJ()+1));
                    }
                }
            }
            queue = temp;
        }
        return res;
    }

    //第二种
    //双层循环遍历  每一个斜面的一行，坐标和是相等的 分别为0,1,2,3...arr.length+arr[0].length-2
    public static  int[] print1(int[][] arr) {
        int[] res = new int[arr.length * arr[0].length];
        int index = 0;
        int j = 0;
        for (int num = 0; num < arr.length + arr[0].length - 1; num++) {
            for(int i=arr.length-1; i>=0; i--) {
                j = num - i;
                if (j >= 0 && j < arr[0].length) {
                    res[index++] = arr[i][j];
                }
            }
        }
        return res;
    }

//    1，2，3，4​
//    5，6，7，8​
//    9，10，11，12​
//    ------​ 斜着打印二维数组
//    1，5，2，9，6，3，10，7，4，11，8，12​
    @Test
    public static void main(String[] args) {
        int [][] arr = new int[][]{{1,2,3,4},{5,6,7,8},{9,10,11,12}};
//        int[] res = print(arr);
        int[] res = print1(arr);
        for (int i = 0; i < res.length; ++i) {
            System.out.println(res[i]);
        }
    }
}