悠然亂彈：螺旋矩陣和蛇型矩陣的悠然版實現

時間 2019-11-09

原文原文鏈接

螺旋矩陣和蛇型矩陣，是兩個比較有趣的矩陣，有許多的公司面試題中有出現，這兩個題的答案也有許多種，簡單問一下度娘，就各自有N種實現，來源也很是豐富，好比CSDN、ITEYE、等等，固然也包括著名的OSC，可是總體看下來，呵呵，比較順眼的比較少，比較經典的就愈加少了。 html

考慮到不一樣的語言有不一樣的語言特性，所以今天就只用Java來進行實現，看看螺旋矩陣和蛇型矩陣的悠然版實現，讓咱們的OSC也更加高大上一些，。 java

概念說明

什麼是螺旋矩陣

螺旋矩陣是指一個呈螺旋狀的矩陣，它的數字由第一行開始到右邊不斷變大，向下變大，
向左變大，向上變大，如此循環。程序員

下面是幾個螺旋矩陣的示例：面試

下面是1階螺旋矩陣:

下面是2階螺旋矩陣:

1 2
4 3

下面是3階螺旋矩陣:

1 2 3
8 9 4
7 6 5

下面是4階螺旋矩陣:

1 2 3 4
12 13 14 5
11 16 15 6
10 9 8 7

下面是5階螺旋矩陣:

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

什麼是蛇型矩陣

這個東東提及來比較抽象，玩過貪吃蛇麼？若是玩過大體就能夠理解了。優化

下面看看實際示例 spa

下面是1階蛇形矩陣:

下面是2階蛇形矩陣:

1 3
2 4

下面是3階蛇形矩陣:

1 3 4
2 5 8
6 7 9

下面是4階蛇形矩陣:

1 3 4 10
2 5 9 11
6 8 12 15
7 13 14 16

下面是5階蛇形矩陣:

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

悠然版解法

螺旋矩陣

分析

簡單看看螺旋矩陣，其規律就是一圈一圈的往裏繞，所以咱們能夠想象有一條貪吃蛇，它很聽話，若是要出格子或者碰到格子裏有數的時候就向右轉一下，而後在它路過的格子裏順序填充上數字就好 .net
代碼

public class SpiralMatrix {
    public static int[][] spiralMatrix(int n) {
        int spiralMatrix[][] = new int[n][n];
        for (int num = 1, x = 0, y = 0, xDir = 1, yDir = 0; num <= n * n; num++) {
            spiralMatrix[x][y] = num;
            if (x + xDir < 0 || y + yDir < 0 || x + xDir == n || y + yDir == n || spiralMatrix[x + xDir][y + yDir] != 0) {//若是到邊界了就換方向
                if (xDir != 0) {
                    yDir = xDir;
                    xDir = 0;
                } else {
                    xDir = -yDir;
                    yDir = 0;
                }
            }
            x += xDir;
            y += yDir;
        }
        return spiralMatrix;
    }

    public static void main(String[] args) {
        for (int num = 1; num < 6; num++) {
            int[][] result = spiralMatrix(num);
            System.out.printf("下面是%s階螺旋矩陣:\n",num);
            for (int i = 0; i < num; i++) {
                for (int j = 0; j < num; j++) {
                    System.out.printf("%3s ", result[j][i]);
                }
                System.out.println();
            }
        }
    }
}

說明

for (int num = 1, x = 0, y = 0, xDir = 1, yDir = 0; num <= n * n; num++)

這裏其實很簡單，只是爲了省點代碼行數，所以把一些變量聲明放這裏了，實際放在外面更合適。

x,y爲貪吃蛇要走過的位置，默認從左上角走起； code

xDir和yDir爲行進的方向，默認是水平向右走。 htm

if (x + xDir < 0 || y + yDir < 0 || x + xDir == n || y + yDir == n || spiralMatrix[x + xDir][y + yDir] != 0)

這裏的意思是，若是要出邊界（一共有4個邊界），或者碰到前面的格子中有數字的時候就調整一下方便。

                if (xDir != 0) {
                    yDir = xDir;
                    xDir = 0;
                } else {
                    xDir = -yDir;
                    yDir = 0;
                }

固然，若是沒有碰到邊界也沒有碰到前面格子有數字，那就不調整方向，讓它繼續走，以下。 blog

            x += xDir;
            y += yDir;

而後，就沒有而後了，而後貪吃蛇同窗就幫咱們完成了任務，來一個大點的看看？

1   2   3   4   5   6   7   8 
 28  29  30  31  32  33  34   9 
 27  48  49  50  51  52  35  10 
 26  47  60  61  62  53  36  11 
 25  46  59  64  63  54  37  12 
 24  45  58  57  56  55  38  13 
 23  44  43  42  41  40  39  14 
 22  21  20  19  18  17  16  15

蛇形矩陣

分析

簡單看看蛇形矩陣，它的規律也很簡單，只不過是如何走的規律變了一些，總結一下就是：貪吃蛇老是斜着走的，若是要走出邊界，那麼就換個方向走，只不過要走出左邊時，就向下移動一個格子走；要走出上邊時，就向右移動一個格子走；要走出下邊格子時，就向右移動一個格子走，要走出右邊格子時，就向下移動一個格子走；若是沒有走出格子，就延着原來的方向走。
代碼

public class SnakeMatrix {
    public static int[][] snakeMatrix(int n) {
        int snakeMatrix[][] = new int[n][n];
        for (int num = 1, x = 0, y = 0, xDir = -1, yDir = 1; num <= n * n; num++) {
            snakeMatrix[x][y] = num;
            if (x + xDir == n) {
                y += xDir;
            } else if (y + yDir == n) {
                x += yDir;
            } else if (x + xDir < 0) {
                y += yDir;
            } else if (y + yDir < 0) {
                x += xDir;
            } else {//其它狀況保持原有方向前行
                x += xDir;
                y += yDir;
                continue;
            }
            xDir = -xDir;
            yDir = -yDir;
        }
        return snakeMatrix;
    }

    public static void main(String[] args) {
        for (int num = 1; num < 6; num++) {
            int[][] result = snakeMatrix(num);
            System.out.printf("下面是%s階蛇形矩陣:\n", num);
            for (int i = 0; i < num; i++) {
                for (int j = 0; j < num; j++) {
                    System.out.printf("%3s ", result[j][i]);
                }
                System.out.println();
            }
        }
    }
}

說明

if (x + xDir == n) {
                y += xDir;
            } else if (y + yDir == n) {
                x += yDir;
            } else if (x + xDir < 0) {
                y += yDir;
            } else if (y + yDir < 0) {
                x += xDir;
            } else {//其它正常轉向
                x += xDir;
                y += yDir;
                continue;
            }

這裏就是上面說的邏輯的實現。

嗯嗯，這裏的判斷多了些，暫時沒有想到如何進行優化，哪位同窗出手優化一下？