题目要求：

1	2	3	4
5	6	7	8
9	10	11	12

打印之后的结果为：

1，2，5，9，6，3，4，7，10，11，8，12

代码实现与分析：

和我们以往的矩阵题目一样，如果我们总是局限于如果变化下标来处理逻辑的话，边界控制可能写着写着就凉凉了。所以我么需要从较为宏观的角度去思考这类问题。

package com.isea.brush;

/**
 * 之字形打印矩阵
 * 思路：指定两个点，A和B，AB两个点均从矩阵的左上角出发，A一直往右走，一次移动一步，
 * 移动到最右边之后，向下移动；B点一直往下走，走到最低端之后，往右走，一次移动一步，
 * A点和B点是解耦的，直到最后两个点相遇
 * A点和B点各自往下走一步之后，就会形成一个对角线，我们打印这个对角线即可
 */
public class ZigZag {
    /**
     * a点：(aR,aC)
     * b点：(bR,bC)
     * @param metric
     */
    public static void printZigZag(int[][] metric){
        int aR = 0;
        int aC = 0;
        int bR = 0;
        int bC = 0;

        // 终止的行和终止的列
        int endR = metric.length - 1;
        int endC = metric[0].length - 1;

        boolean fromUp = false;
        while(aR != endR + 1){
            printZigZag(metric,aR,aC,bR,bC,fromUp);
/*            aR = aC == endC ? aR + 1 : aR ;
            aC = aC == endC ? aC  : aC + 1;
            bC = bR == endR ? bC + 1 : bC ;
            bR = bR == endR ? bR  : bR + 1;*/

            aR = aC != endC ? aR : aR + 1 ;
            aC = aC != endC ? aC + 1  : aC ;
            bC = bR != endR ? bC : bC  + 1;
            bR = bR != endR ? bR + 1  : bR;

            fromUp = !fromUp;
        }

    }

    private static void printZigZag(int[][] metric, int aR, int aC, int bR, int bC, boolean fromUp) {
        if (fromUp){
            while(aR != bR + 1){
                System.out.print(metric[aR ++][aC --] + " ");
            }
        }else {
            while(bR != aR - 1){
                System.out.print(metric[bR --][bC ++] + " ");
            }
        }
    }

    public static void main(String[] args){
        int[][] metric = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
        for (int i = 0; i < metric.length; i++) {
            for (int j = 0; j < metric[i].length; j++) {
                System.out.print(metric[i][j] + " ");
            }
            System.out.println();
        }
        printZigZag(metric);
    }
    /**
     * 1 2 3 4
     * 5 6 7 8
     * 9 10 11 12
     * 1 2 5 9 6 3 4 7 10 11 8 12 
     */
}