劍指Offer_Java_順時針打印矩陣（二維數組）

順（逆）時針打印矩陣

算法思想：

簡單來說，就是不斷地收縮矩陣的邊界
定義四個變量代表范圍，up（初始0）、down（初始-行高）、left（初始-0）、right（初始-列寬），
向右走存入整行的值，當存入后，該行再也不會被遍歷，代表上邊界的 up 加一，同時判斷是否和代表下邊界的 down 交錯；
向下走存入整列的值，當存入后，該列再也不會被遍歷，代表右邊界的 right 減一，同時判斷是否和代表左邊界的 left 交錯；
向左走存入整行的值，當存入后，該行再也不會被遍歷，代表下邊界的 down 減一，同時判斷是否和代表上邊界的 up 交錯；
向上走存入整列的值，當存入后，該列再也不會被遍歷，代表左邊界的 left 加一，同時判斷是否和代表右邊界的 right 交錯。

實現代碼（非原創）：

/**
 * 
 */
package com.cherish.SwordRefersToOffer;

import java.util.ArrayList;

/**
 * @author acer
 *
 */
public class test18_順時針打印矩陣 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO 自動生成的方法存根
        int[][] matrix = new int[][]{{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
        ArrayList<Integer> list = printMatrix(matrix);
        System.out.println(list);

    }
    
    
    /*
     * 
        簡單來說，就是不斷地收縮矩陣的邊界
        定義四個變量代表范圍，up、down、left、right        
        向右走存入整行的值，當存入后，該行再也不會被遍歷，代表上邊界的 up 加一，同時判斷是否和代表下邊界的 down 交錯
        向下走存入整列的值，當存入后，該列再也不會被遍歷，代表右邊界的 right 減一，同時判斷是否和代表左邊界的 left 交錯
        向左走存入整行的值，當存入后，該行再也不會被遍歷，代表下邊界的 down 減一，同時判斷是否和代表上邊界的 up 交錯
        向上走存入整列的值，當存入后，該列再也不會被遍歷，代表左邊界的 left 加一，同時判斷是否和代表右邊界的 right 交錯
     * 
     * */
    /*
     * 1  2  3  4
     * 5  6  7  8
     * 9 10  11 12
     * 13 14 15 16
     * */
    
    //順時針打印矩陣
    public static ArrayList<Integer> printMatrix(int [][] matrix) {
          ArrayList<Integer>  list = new ArrayList<>();
          if(matrix == null||matrix.length ==0) 
          {
              return list;
          }
          int up = 0;
          int down = matrix.length - 1; //行高
          int left = 0;
          int right = matrix[0].length - 1; // 列高
          while(true)
          {
              //向右
              for(int i = left;i<=right;i++)
              {
                  list.add(matrix[up][i]);
              }
              if(++up > down)
              {
                  break;
              }
              //向下
              for(int i = up;i<=down;i++)
              {
                  list.add(matrix[i][right]);
              }
              if(--right < left)
              {
                  break;
              }
              //向左
              for(int i = right;i>=left;i--)
              {
                  list.add(matrix[down][i]);
              }
              if(--down < up)
              {
                  break;
              }
              //向上
              for(int i = down;i>=up;i--)
              {
                  list.add(matrix[i][left]);
              }
              if(++left > right)
              {
                  break;
              }
          }
          return list;
    }

}

 

實現結果：