以螺旋形式打印给定的矩阵

给定一个二维数组，以螺旋形式打印。请参阅以下示例。

例子：

Input:  {{1,    2,   3,   4},
              {5,    6,   7,   8},
             {9,   10,  11,  12},
            {13,  14,  15,  16 }}
Output: 1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10 
Explanation: The output is matrix in spiral format. 

Input: { {1,   2,   3,   4,  5,   6},
           {7,   8,   9,  10,  11,  12},
          {13,  14,  15, 16,  17,  18}}

Output: 1 2 3 4 5 6 12 18 17 16 15 14 13 7 8 9 10 11
Explanation :The output is matrix in spiral format.

最佳优化方法1：（模拟方法）

直觉：

画出螺旋形成的路径。我们知道，只要路径超出边界或进入先前访问过的单元格，路径就应该顺时针转动。

算法：

让数组有 R 行和 C 列。 seen[r] 表示先前访问过第 r 行第 c 列的单元格。我们当前的位置是 (r, c)，面向方向 di，我们要访问 R x C 个总细胞。

当我们在矩阵中移动时，候选者的下一个位置是 (cr, cc)。如果候选人在矩阵的范围内并且看不见，那么它将成为我们的下一个位置；否则，我们的下一个位置是顺时针转动后的位置。

C++

#include 
using namespace std;
 
vector spiralOrder(vector> &matrix)
{
    vector ans;
 
    if (matrix.size() == 0)
        return ans;
 
    int R = matrix.size(), C = matrix[0].size();
    vector> seen(R, vector(C, false));
    int dr[] = {0, 1, 0, -1};
    int dc[] = {1, 0, -1, 0};
    int r = 0, c = 0, di = 0;
 
    // Iterate from 0 to R * C - 1
    for (int i = 0; i < R * C; i++)
    {
        ans.push_back(matrix[r]);
        seen[r] = true;
        int cr = r + dr[di];
        int cc = c + dc[di];
 
        if (0 <= cr && cr < R && 0 <= cc && cc < C && !seen[cr][cc])
        {
            r = cr;
            c = cc;
        }
        else
        {
            di = (di + 1) % 4;
            r += dr[di];
            c += dc[di];
        }
    }
    return ans;
}
 
// Driver code
int main()
{
    vector> a{{1, 2, 3, 4},
                          {5, 6, 7, 8},
                          {9, 10, 11, 12},
                          {13, 14, 15, 16}};
 
    for (int x : spiralOrder(a))
    {
        cout << x << " ";
    }
    return 0;
}
 
// This code is contributed by Yashvendra Singh

Java

// Java program for the above approach
import java.util.*;
 
class Solution {
 
    // Function to print in spiral order
    public static List spiralOrder(int[][] matrix) {
        List ans = new ArrayList();
 
        if (matrix.length == 0)
            return ans;
 
        int R = matrix.length, C = matrix[0].length;
        boolean[][] seen = new boolean[R][C];
        int[] dr = { 0, 1, 0, -1 };
        int[] dc = { 1, 0, -1, 0 };
        int r = 0, c = 0, di = 0;
 
        // Iterate from 0 to R * C - 1
        for (int i = 0; i < R * C; i++) {
            ans.add(matrix[r]);
            seen[r] = true;
            int cr = r + dr[di];
            int cc = c + dc[di];
 
            if (0 <= cr && cr < R && 0 <= cc && cc < C
                    && !seen[cr][cc]) {
                r = cr;
                c = cc;
            } else {
                di = (di + 1) % 4;
                r += dr[di];
                c += dc[di];
            }
        }
        return ans;
    }
 
    // Driver Code
    public static void main(String[] args) {
        int a[][] = { { 1, 2, 3, 4 },
                { 5, 6, 7, 8 },
                { 9, 10, 11, 12 },
                { 13, 14, 15, 16 } };
 
        System.out.println(spiralOrder(a));
    }
}

Python3

def spiralOrder(matrix):
    ans = []
 
    if (len(matrix) == 0):
        return ans
 
    R = len(matrix)
    C = len(matrix[0])
    seen = [[0 for i in range(C)] for j in range(R)]
    dr = [0, 1, 0, -1]
    dc = [1, 0, -1, 0]
    r = 0
    c = 0
    di = 0
 
    # Iterate from 0 to R * C - 1
    for i in range(R * C):
        ans.append(matrix[r])
        seen[r] = True
        cr = r + dr[di]
        cc = c + dc[di]
 
        if (0 <= cr and cr < R and 0 <= cc and cc < C and not(seen[cr][cc])):
            r = cr
            c = cc
        else:
            di = (di + 1) % 4
            r += dr[di]
            c += dc[di]
    return ans
 
 
# Driver code
a = [[1, 2, 3, 4],
     [5, 6, 7, 8],
     [9, 10, 11, 12],
     [13, 14, 15, 16]]
 
for x in spiralOrder(a):
    print(x, end=" ")
print()

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
 
public class GFG {
 
    // Function to print in spiral order
    public static List spiralOrder(int[,] matrix)
    {
        List ans = new List();
 
        if (matrix.Length == 0)
            return ans;
 
        int R = matrix.GetLength(0), C = matrix.GetLength(1);
        bool[,] seen = new bool[R,C];
        int[] dr = { 0, 1, 0, -1 };
        int[] dc = { 1, 0, -1, 0 };
        int r = 0, c = 0, di = 0;
 
        // Iterate from 0 to R * C - 1
        for (int i = 0; i < R * C; i++) {
            ans.Add(matrix[r,c]);
            seen[r,c] = true;
            int cr = r + dr[di];
            int cc = c + dc[di];
 
            if (0 <= cr && cr < R && 0 <= cc && cc < C
                && !seen[cr,cc]) {
                r = cr;
                c = cc;
            }
            else {
                di = (di + 1) % 4;
                r += dr[di];
                c += dc[di];
            }
        }
        return ans;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int[,]a = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 9, 10, 11, 12 },
                      { 13, 14, 15, 16 } };
 
        spiralOrder(a).ForEach(i=>Console.Write(i+" "));
    }
}
 
// This code is contributed by 29AjayKumar

Javascript

 
// JavaScript program for the above approach
 
// Function to print in spiral order
function spiralOrder(matrix)
{
    let ans = [];
  
        if (matrix.length == 0)
            return ans;
  
        let R = matrix.length, C = matrix[0].length;
        let seen = new Array(R);
        for(let i=0;i<R;i++)
        {
            seen[i]=new Array(C);
            for(let j=0;j<C;j++)
            {
                seen[i][j]=false;
            }
        }
         
        let dr = [ 0, 1, 0, -1 ];
        let dc = [ 1, 0, -1, 0 ];
        let r = 0, c = 0, di = 0;
  
        // Iterate from 0 to R * C - 1
        for (let i = 0; i < R * C; i++) {
            ans.push(matrix[r]);
            seen[r] = true;
            let cr = r + dr[di];
            let cc = c + dc[di];
  
            if (0 <= cr && cr < R && 0 <= cc && cc < C
                && !seen[cr][cc]) {
                r = cr;
                c = cc;
            }
            else {
                di = (di + 1) % 4;
                r += dr[di];
                c += dc[di];
            }
        }
        return ans;
}
 
// Driver Code
let a=[[ 1, 2, 3, 4 ],[ 5, 6, 7, 8 ],
[ 9, 10, 11, 12 ],[ 13, 14, 15, 16 ]];
document.write(spiralOrder(a));
                       
 
 
// This code is contributed by unknown2108
 

输出

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

复杂性分析：

• 时间复杂度： O(N)，其中 N 是输入矩阵中元素的总数。我们将矩阵中的每个元素添加到最终答案中。
• 辅助空间： O(N)，存储在seen和ans中的信息。

方法2 ：这是解决以下问题的简单方法。

方法：可以通过将矩阵划分为循环或正方形或边界来解决问题。可以看出，首先以顺时针方式打印外循环的元素，然后打印内循环的元素。因此，可以使用打印所有元素的四个循环来解决打印循环的元素。每个“for”循环都定义了与矩阵一起的单向运动。第一个 for 循环代表从左到右的移动，而第二个 crawl 代表从上到下的移动，第三个代表从右到左的移动，第四个代表从下到上的移动。

• 算法：
  1. 创建和初始化变量 k - 起始行索引，m - 结束行索引，l - 起始列索引，n - 结束列索引
  2. 运行一个循环，直到打印出所有的循环方块。
  3. 在每个外部循环遍历中，以顺时针方式打印正方形的元素。
  4. 打印顶行，即打印列索引l到n的第k行的元素，增加k的计数。
  5. 打印右列，即打印从行索引k到m的最后一列或第n-1列，并减少n的计数。
  6. 打印底行，即如果k < m，则打印第n-1列到l的第m-1行的元素，并减少m的计数
  7. 打印左列，即如果 l < n，则将第 l 列的元素从 m-1 行打印到 k 并增加 l 的计数。

下面是上述算法的实现：

C++

// C++ Program to print a matrix spirally
 
#include 
using namespace std;
#define R 4
#define C 4
 
void spiralPrint(int m, int n, int a[R][C])
{
    int i, k = 0, l = 0;
 
    /* k - starting row index
        m - ending row index
        l - starting column index
        n - ending column index
        i - iterator
    */
 
    while (k < m && l < n) {
        /* Print the first row from
               the remaining rows */
        for (i = l; i < n; ++i) {
            cout << a[k][i] << " ";
        }
        k++;
 
        /* Print the last column
         from the remaining columns */
        for (i = k; i < m; ++i) {
            cout << a[i][n - 1] << " ";
        }
        n--;
 
        /* Print the last row from
                the remaining rows */
        if (k < m) {
            for (i = n - 1; i >= l; --i) {
                cout << a[m - 1][i] << " ";
            }
            m--;
        }
 
        /* Print the first column from
                   the remaining columns */
        if (l < n) {
            for (i = m - 1; i >= k; --i) {
                cout << a[i][l] << " ";
            }
            l++;
        }
    }
}
 
/* Driver Code */
int main()
{
    int a[R][C] = {{1, 2, 3, 4},
                   {5, 6, 7, 8},
                   {9, 10, 11, 12},
                   {13, 14, 15, 16}};
 
    // Function Call
    spiralPrint(R, C, a);
    return 0;
}
 
// This is code is contributed by rathbhupendra

C

// C program to print the array in a
// spiral form
 
#include 
#define R 4
#define C 4
 
void spiralPrint(int m, int n, int a[R][C])
{
    int i, k = 0, l = 0;
 
    /*  k - starting row index
        m - ending row index
        l - starting column index
        n - ending column index
        i - iterator
    */
 
    while (k < m && l < n) {
        /* Print the first row from the remaining rows */
        for (i = l; i < n; ++i) {
            printf("%d ", a[k][i]);
        }
        k++;
 
        /* Print the last column from the remaining columns
         */
        for (i = k; i < m; ++i) {
            printf("%d ", a[i][n - 1]);
        }
        n--;
 
        /* Print the last row from the remaining rows */
        if (k < m) {
            for (i = n - 1; i >= l; --i) {
                printf("%d ", a[m - 1][i]);
            }
            m--;
        }
 
        /* Print the first column from the remaining columns
         */
        if (l < n) {
            for (i = m - 1; i >= k; --i) {
                printf("%d ", a[i][l]);
            }
            l++;
        }
    }
}
 
/* Driver Code */
int main()
{
    int a[R][C] =  {{1, 2, 3, 4},
                   {5, 6, 7, 8},
                   {9, 10, 11, 12},
                   {13, 14, 15, 16}};
 
    // Function Call
    spiralPrint(R, C, a);
    return 0;
}

Java

// Java program to print a given matrix in spiral form
import java.io.*;
 
class GFG {
 
    // Function print matrix in spiral form
    static void spiralPrint(int m, int n, int a[][])
    {
        int i, k = 0, l = 0;
 
        /*  k - starting row index
        m - ending row index
        l - starting column index
        n - ending column index
        i - iterator
        */
 
        while (k < m && l < n) {
            // Print the first row from the remaining rows
            for (i = l; i < n; ++i) {
                System.out.print(a[k][i] + " ");
            }
            k++;
 
            // Print the last column from the remaining
            // columns
            for (i = k; i < m; ++i) {
                System.out.print(a[i][n - 1] + " ");
            }
            n--;
 
            // Print the last row from the remaining rows */
            if (k < m) {
                for (i = n - 1; i >= l; --i) {
                    System.out.print(a[m - 1][i] + " ");
                }
                m--;
            }
 
            // Print the first column from the remaining
            // columns */
            if (l < n) {
                for (i = m - 1; i >= k; --i) {
                    System.out.print(a[i][l] + " ");
                }
                l++;
            }
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int R = 4;
        int C = 4;
        int a[][] =  {{1, 2, 3, 4},
                   {5, 6, 7, 8},
                   {9, 10, 11, 12},
                   {13, 14, 15, 16}};
 
        // Function Call
        spiralPrint(R, C, a);
    }
}
 
// Contributed by Pramod Kumar

Python3

# Python3 program to print
# given matrix in spiral form
 
 
def spiralPrint(m, n, a):
    k = 0
    l = 0
 
    ''' k - starting row index
        m - ending row index
        l - starting column index
        n - ending column index
        i - iterator '''
 
    while (k < m and l < n):
 
        # Print the first row from
        # the remaining rows
        for i in range(l, n):
            print(a[k][i], end=" ")
 
        k += 1
 
        # Print the last column from
        # the remaining columns
        for i in range(k, m):
            print(a[i][n - 1], end=" ")
 
        n -= 1
 
        # Print the last row from
        # the remaining rows
        if (k < m):
 
            for i in range(n - 1, (l - 1), -1):
                print(a[m - 1][i], end=" ")
 
            m -= 1
 
        # Print the first column from
        # the remaining columns
        if (l < n):
            for i in range(m - 1, k - 1, -1):
                print(a[i][l], end=" ")
 
            l += 1
 
 
# Driver Code
a = [[ 1, 2, 3, 4 ],
     [ 5, 6, 7, 8 ],
     [ 9, 10, 11, 12 ],
     [ 13, 14, 15, 16 ]]
 
R = 4
C = 4
 
# Function Call
spiralPrint(R, C, a)
 
# This code is contributed by Nikita Tiwari.

C＃

// C# program to print a given
// matrix in spiral form
using System;
 
class GFG {
    // Function print matrix in spiral form
    static void spiralPrint(int m, int n, int[, ] a)
    {
        int i, k = 0, l = 0;
        /* k - starting row index
        m - ending row index
        l - starting column index
        n - ending column index
        i - iterator
        */
 
        while (k < m && l < n) {
            // Print the first row
            // from the remaining rows
            for (i = l; i < n; ++i) {
                Console.Write(a[k, i] + " ");
            }
            k++;
 
            // Print the last column from the
            // remaining columns
            for (i = k; i < m; ++i) {
                Console.Write(a[i, n - 1] + " ");
            }
            n--;
 
            // Print the last row from
            // the remaining rows
            if (k < m) {
                for (i = n - 1; i >= l; --i) {
                    Console.Write(a[m - 1, i] + " ");
                }
                m--;
            }
 
            // Print the first column from
            // the remaining columns
            if (l < n) {
                for (i = m - 1; i >= k; --i) {
                    Console.Write(a[i, l] + " ");
                }
                l++;
            }
        }
    }
 
    // Driver Code
    public static void Main()
    {
        int R = 4;
        int C = 4;
        int[, ] a =  {{1, 2, 3, 4},
                   {5, 6, 7, 8},
                   {9, 10, 11, 12},
                   {13, 14, 15, 16}};
 
        // Function Call
        spiralPrint(R, C, a);
    }
}
 
// This code is contributed by Sam007

PHP

= $l; --$i)
            {
                echo $a[$m - 1][$i] . " ";
            }
            $m--;
        }
 
        /* Print the first column from
           the remaining columns */
        if ($l < $n)
        {
            for ($i = $m - 1; $i >= $k; --$i)
            {
                echo $a[$i][$l] . " ";
            }
            $l++;
        }    
    }
}
 
// Driver code
$a = array(array(1, 2, 3, 4),
           array(5, 6, 7, 8),
           array(9, 10, 11, 12),
           array(13, 14, 15, 16));
// Function Call
spiralPrint($R, $C, $a);
 
// This code is contributed
// by ChitraNayal
?>

Javascript

 
// JavaScript Program to print a matrix spirally
 
function spiralPrint(m, n, arr) {
    let i, k = 0, l = 0;
    /*
        k - starting row index
        m - ending row index
        l - starting column index
        n - ending column index
        i - iterator 
    */
 
    while (k < m && l < n) {
        // print the first row from the remaining rows
        for (i = l; i < n; ++i) {
            document.write(arr[k][i] + ' ');
        }
        k++;
 
        // print the last column from the remaining columns
        for (i = k; i < m; ++i) {
            document.write(arr[i][n - 1] + ' ');
        }
        n--;
 
        // print the last row from the remaining rows
        if (k < m) {
            for (i = n - 1; i >= l; --i) {
                document.write(arr[m - 1][i] + ' ');
            }
            m--;
        }
 
        // print the first column from the remaining columns
        if (l < n) {
            for (i = m - 1; i >= k; --i) {
                document.write(arr[i][l] + ' ');
            }
            l++;
        }
    }
}
 
// function call
let arr = [[ 1, 2, 3, 4 ],
     [ 5, 6, 7, 8 ],
     [ 9, 10, 11, 12 ],
     [ 13, 14, 15, 16 ]];
let r = arr.length;
let c = arr[0].length;
 
spiralPrint(r, c, arr);
 
// This code is contributed by karthiksrinivasprasad
 

输出

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

复杂性分析：

• 时间复杂度： O(m*n)。
  遍历矩阵需要 O(m*n) 时间。
• 辅助空间： O(1)。
  不需要额外的空间。

方法3 ：（递归方法）

方法：上述问题可以通过递归打印Matrix的边界来解决。在每次递归调用中，我们都会减少矩阵的维度。打印边界或循环的想法是相同的。

• 算法：
  1. 创建一个递归函数，以矩阵和一些变量（k - 起始行索引，m - 结束行索引，l - 起始列索引，n - 结束列索引）作为参数
  2. 检查基本情况（起始索引小于或等于结束索引）并以顺时针方式打印边界元素
  3. 打印顶行，即打印列索引l到n的第k行的元素，增加k的个数。
  4. 打印右列，即打印从行索引k到m的最后一列或第n-1列，并减少n的计数。
  5. 打印最下面一行，即如果k > m，则打印第n-1列到l列第m-1行的元素，并减少m的个数
  6. 打印左列，即如果 l < n，则将第 l 列的元素从 m-1 行打印到 k 并增加 l 的计数。
  7. 使用行和列的开始和结束索引的值递归调用该函数。

下面是上述算法的实现：

C++

// C++. program for the above approach
#include 
using namespace std;
 
#define R 4
#define C 4
 
// Function for printing matrix in spiral
// form i, j: Start index of matrix, row
// and column respectively m, n: End index
// of matrix row and column respectively
void print(int arr[R][C], int i, int j, int m, int n)
{
    // If i or j lies outside the matrix
    if (i >= m or j >= n)
        return;
 
    // Print First Row
    for (int p = j; p < n; p++)
        cout << arr[i][p] << " ";
 
    // Print Last Column
    for (int p = i + 1; p < m; p++)
        cout << arr[p][n - 1] << " ";
 
    // Print Last Row, if Last and
    // First Row are not same
    if ((m - 1) != i)
        for (int p = n - 2; p >= j; p--)
            cout << arr[m - 1][p] << " ";
 
    // Print First Column,  if Last and
    // First Column are not same
    if ((n - 1) != j)
        for (int p = m - 2; p > i; p--)
            cout << arr[p][j] << " ";
 
    print(arr, i + 1, j + 1, m - 1, n - 1);
}
 
// Driver Code
int main()
{
 
    int a[R][C] = { { 1, 2, 3, 4 },
                    { 5, 6, 7, 8 },
                    { 9, 10, 11, 12 },
                    { 13, 14, 15, 16 } };
 
    // Function Call
    print(a, 0, 0, R, C);
    return 0;
}
// This Code is contributed by Ankur Goel

Java

// Java program for the above approach
import java.util.*;
 
class GFG {
    static int R = 4;
    static int C = 4;
 
    // Function for printing matrix in spiral
    // form i, j: Start index of matrix, row
    // and column respectively m, n: End index
    // of matrix row and column respectively
    static void print(int arr[][], int i, int j, int m,
                      int n)
    {
        // If i or j lies outside the matrix
        if (i >= m || j >= n) {
            return;
        }
 
        // Print First Row
        for (int p = i; p < n; p++) {
            System.out.print(arr[i][p] + " ");
        }
 
        // Print Last Column
        for (int p = i + 1; p < m; p++) {
            System.out.print(arr[p][n - 1] + " ");
        }
 
        // Print Last Row, if Last and
        // First Row are not same
        if ((m - 1) != i) {
            for (int p = n - 2; p >= j; p--) {
                System.out.print(arr[m - 1][p] + " ");
            }
        }
 
        // Print First Column, if Last and
        // First Column are not same
        if ((n - 1) != j) {
            for (int p = m - 2; p > i; p--) {
                System.out.print(arr[p][j] + " ");
            }
        }
        print(arr, i + 1, j + 1, m - 1, n - 1);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int a[][] = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 9, 10, 11, 12 },
                      { 13, 14, 15, 16 } };
 
        // Function Call
        print(a, 0, 0, R, C);
    }
}
 
// This code is contributed by 29AjayKumar

Python3

# Python3 program for the above approach
 
# Function for printing matrix in spiral
# form i, j: Start index of matrix, row
# and column respectively m, n: End index
# of matrix row and column respectively
 
 
def printdata(arr, i, j, m, n):
 
    # If i or j lies outside the matrix
    if (i >= m or j >= n):
        return
 
    # Print First Row
    for p in range(i, n):
        print(arr[i][p], end=" ")
 
    # Print Last Column
    for p in range(i + 1, m):
        print(arr[p][n - 1], end=" ")
 
    # Print Last Row, if Last and
    # First Row are not same
    if ((m - 1) != i):
        for p in range(n - 2, j - 1, -1):
            print(arr[m - 1][p], end=" ")
 
    # Print First Column, if Last and
    # First Column are not same
    if ((n - 1) != j):
        for p in range(m - 2, i, -1):
            print(arr[p][j], end=" ")
 
    printdata(arr, i + 1, j + 1, m - 1, n - 1)
 
 
# Driver code
R = 4
C = 4
arr = [[1, 2, 3, 4],
       [5, 6, 7, 8],
       [9, 10, 11, 12],
       [13, 14, 15, 16]]
 
# Function Call
printdata(arr, 0, 0, R, C)
 
# This code is contributed by avsadityavardhan

C＃

// C# program for the above approach
using System;
 
class GFG {
    static int R = 4;
    static int C = 4;
 
    // Function for printing matrix in spiral
    // form i, j: Start index of matrix, row
    // and column respectively m, n: End index
    // of matrix row and column respectively
    static void print(int[, ] arr, int i, int j, int m,
                      int n)
    {
        // If i or j lies outside the matrix
        if (i >= m || j >= n) {
            return;
        }
 
        // Print First Row
        for (int p = i; p < n; p++) {
            Console.Write(arr[i, p] + " ");
        }
 
        // Print Last Column
        for (int p = i + 1; p < m; p++) {
            Console.Write(arr[p, n - 1] + " ");
        }
 
        // Print Last Row, if Last and
        // First Row are not same
        if ((m - 1) != i) {
            for (int p = n - 2; p >= j; p--) {
                Console.Write(arr[m - 1, p] + " ");
            }
        }
 
        // Print First Column, if Last and
        // First Column are not same
        if ((n - 1) != j) {
            for (int p = m - 2; p > i; p--) {
                Console.Write(arr[p, j] + " ");
            }
        }
        print(arr, i + 1, j + 1, m - 1, n - 1);
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int[, ] a = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 9, 10, 11, 12 },
                      { 13, 14, 15, 16 } };
        // Function Call
        print(a, 0, 0, R, C);
    }
}
 
// This code is contributed by Princi Singh

Javascript

// JavaScript program for the above approach
 
// Function for printing matrix in spiral
// form i, j: Start index of matrix, row
// and column respectively m, n: End index
// of matrix row and column respectively
 
function print(arr, i, j, m, n) {
 
    // If i or j lies outside the matrix
    if (i >= m || j >= n) return;
 
    // Print First Row
    for (let p = j; p < n; p++) {
        document.write(arr[i][p] + ' ')
    }
 
    // Print Last Column
    for (let p = i + 1; p < m; p++) {
        document.write(arr[p][n - 1] + ' ')
    }
 
    // Print Last Row, if Last and
    // First Row are not same
    if ((m - 1) != i) {
        for (let p = n - 2; p >= j; p--) {
            document.write(arr[m - 1][p] + ' ');
        }
    }
 
    // Print First Column, if Last and
    // First Column are not same   
    if ((n - 1) != j) {
        for (let p = m - 2; p > i; p--) {
            document.write(arr[p][j] + ' ');
        }
    }
    print(arr, i + 1, j + 1, m - 1, n - 1)
}
 
// function call
let arr = [ [1, 2, 3, 4],
            [5, 6, 7, 8],
            [9, 10, 11, 12],
            [13, 14, 15, 16]
           ];
let r = arr.length;
let c = arr[0].length;
 
print(arr, 0, 0, r, c);
 
// This code is contributed by karthiksrinivasprasad
 

输出

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

复杂性分析：

• 时间复杂度： O(m*n)。
  遍历矩阵需要 O(m*n) 时间。
• 辅助空间： O(1)。
  不需要额外的空间。

方法4： （DFS递归方法）

方法：另一种递归方法是考虑矩阵内的 DFS 移动（右->下->左->上->右->..->结束）。

我们通过修改矩阵本身来做到这一点，这样当 DFS 算法访问每个矩阵单元时，它会更改为一个不能包含在矩阵中的值。 DFS 算法在访问一个小区时终止，使得它周围的所有小区都已被访问过。 DFS 搜索的方向由变量控制。

算法：

1. 创建一个 DFS函数，它采用矩阵、单元索引和方向
2. 检查单元格索引是否指向有效单元格（即未访问且在边界内）？如果没有，请跳过此单元格
3. 打印单元格值
4. 通过将其更改为矩阵中不支持的值，将指向的矩阵单元标记为已访问
5. 检查周围的细胞是否有效？如果不停止算法，否则继续
6. 如果给出的方向是正确的，那么检查，右边的单元格是否有效？如果是这样，根据上述步骤，DFS 到右侧单元格，否则，根据上述步骤将方向更改为向下和 DFS 向下。
7. 否则，如果给定的方向是向下然后检查，向下的单元格是否有效？如果是这样，根据上述步骤，DFS 到下面的单元格，否则，在上述步骤的情况下，将方向更改为向左和 DFS 向左。
8. 否则，如果给定的方向是左侧，那么检查左侧的单元格是否有效？如果是这样，则根据上述步骤将 DFS 移动到左侧单元格，否则，根据上述步骤将方向更改为向上和 DFS 向上。
9. 否则，如果给出的方向是向上的，那么检查向上的单元格是否有效？如果是这样，根据上述步骤，DFS 到上部单元格，否则，根据上述步骤将方向更改为向右和 DFS 向右。

下面是这个算法的一个实现：

C++

#include 
#include 
using namespace std;
#define R 4
#define C 4
 
bool isInBounds(int i, int j)
{
    if (i < 0 || i >= R || j < 0 || j >= C)
        return false;
    return true;
}
 
// check if the position is blocked
bool isBlocked(int matrix[R][C], int i, int j)
{
    if (!isInBounds(i, j))
        return true;
    if (matrix[i][j] == -1)
        return true;
    return false;
}
 
// DFS code to traverse spirally
void spirallyDFSTravserse(int matrix[R][C], int i, int j,
                          int dir, vector& res)
{
    if (isBlocked(matrix, i, j))
        return;
    bool allBlocked = true;
    for (int k = -1; k <= 1; k += 2) {
        allBlocked = allBlocked
                     && isBlocked(matrix, k + i, j)
                     && isBlocked(matrix, i, j + k);
    }
    res.push_back(matrix[i][j]);
    matrix[i][j] = -1;
    if (allBlocked) {
        return;
    }
 
    // dir: 0 - right, 1 - down, 2 - left, 3 - up
    int nxt_i = i;
    int nxt_j = j;
    int nxt_dir = dir;
    if (dir == 0) {
        if (!isBlocked(matrix, i, j + 1)) {
            nxt_j++;
        }
        else {
            nxt_dir = 1;
            nxt_i++;
        }
    }
    else if (dir == 1) {
        if (!isBlocked(matrix, i + 1, j)) {
            nxt_i++;
        }
        else {
            nxt_dir = 2;
            nxt_j--;
        }
    }
    else if (dir == 2) {
        if (!isBlocked(matrix, i, j - 1)) {
            nxt_j--;
        }
        else {
            nxt_dir = 3;
            nxt_i--;
        }
    }
    else if (dir == 3) {
        if (!isBlocked(matrix, i - 1, j)) {
            nxt_i--;
        }
        else {
            nxt_dir = 0;
            nxt_j++;
        }
    }
    spirallyDFSTravserse(matrix, nxt_i, nxt_j, nxt_dir,
                         res);
}
 
// to traverse spirally
vector spirallyTraverse(int matrix[R][C])
{
    vector res;
    spirallyDFSTravserse(matrix, 0, 0, 0, res);
    return res;
}
 
// Driver Code
int main()
{
    int a[R][C] = { { 1, 2, 3, 4 },
                    { 5, 6, 7, 8 },
                    { 9, 10, 11, 12 },
                    { 13, 14, 15, 16 } };
 
    // Function Call
    vector res = spirallyTraverse(a);
    int size = res.size();
    for (int i = 0; i < size; ++i)
        cout << res[i] << " ";
    cout << endl;
    return 0;
} // code contributed by Ephi F

Java

import java.io.*;
import java.util.*;
 
class GFG {
    public static int R = 4, C = 4;
    public static boolean isInBounds(int i, int j)
    {
        if (i < 0 || i >= R || j < 0 || j >= C)
            return false;
        return true;
    }
 
    // check if the position is blocked
    public static boolean isBlocked(int[][] matrix, int i,
                                    int j)
    {
        if (!isInBounds(i, j))
            return true;
        if (matrix[i][j] == -1)
            return true;
        return false;
    }
 
    // DFS code to traverse spirally
    public static void
    spirallyDFSTravserse(int[][] matrix, int i, int j,
                         int dir, ArrayList res)
    {
        if (isBlocked(matrix, i, j))
            return;
        boolean allBlocked = true;
        for (int k = -1; k <= 1; k += 2) {
            allBlocked = allBlocked
                         && isBlocked(matrix, k + i, j)
                         && isBlocked(matrix, i, j + k);
        }
        res.add(matrix[i][j]);
        matrix[i][j] = -1;
        if (allBlocked) {
            return;
        }
 
        // dir: 0 - right, 1 - down, 2 - left, 3 - up
        int nxt_i = i;
        int nxt_j = j;
        int nxt_dir = dir;
        if (dir == 0) {
            if (!isBlocked(matrix, i, j + 1)) {
                nxt_j++;
            }
            else {
                nxt_dir = 1;
                nxt_i++;
            }
        }
        else if (dir == 1) {
            if (!isBlocked(matrix, i + 1, j)) {
                nxt_i++;
            }
            else {
                nxt_dir = 2;
                nxt_j--;
            }
        }
        else if (dir == 2) {
            if (!isBlocked(matrix, i, j - 1)) {
                nxt_j--;
            }
            else {
                nxt_dir = 3;
                nxt_i--;
            }
        }
        else if (dir == 3) {
            if (!isBlocked(matrix, i - 1, j)) {
                nxt_i--;
            }
            else {
                nxt_dir = 0;
                nxt_j++;
            }
        }
        spirallyDFSTravserse(matrix, nxt_i, nxt_j, nxt_dir,
                             res);
    }
 
    // to traverse spirally
    public static ArrayList
    spirallyTraverse(int[][] matrix)
    {
        ArrayList res = new ArrayList();
        spirallyDFSTravserse(matrix, 0, 0, 0, res);
        return res;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int a[][] = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 9, 10, 11, 12 },
                      { 13, 14, 15, 16 } };
 
        // Function Call
        ArrayList res = spirallyTraverse(a);
        int size = res.size();
        for (int i = 0; i < size; ++i)
            System.out.print(res.get(i) + " ");
        System.out.println();
    }
}
 
// This code is contributed by Manu Pathria

Python3

R = 4
C = 4
 
 
def isInBounds(i, j):
    global R
    global C
    if (i < 0 or i >= R or j < 0 or j >= C):
        return False
    return True
 
# Check if the position is blocked
 
 
def isBlocked(matrix, i, j):
    if (not isInBounds(i, j)):
        return True
    if (matrix[i][j] == -1):
        return True
 
    return False
 
# DFS code to traverse spirally
 
 
def spirallyDFSTravserse(matrix, i, j, Dir, res):
    if (isBlocked(matrix, i, j)):
        return
 
    allBlocked = True
    for k in range(-1, 2, 2):
        allBlocked = allBlocked and isBlocked(
            matrix, k + i, j) and isBlocked(matrix, i, j + k)
 
    res.append(matrix[i][j])
    matrix[i][j] = -1
    if (allBlocked):
        return
 
    # dir: 0 - right, 1 - down, 2 - left, 3 - up
    nxt_i = i
    nxt_j = j
    nxt_dir = Dir
    if (Dir == 0):
        if (not isBlocked(matrix, i, j + 1)):
            nxt_j += 1
        else:
            nxt_dir = 1
            nxt_i += 1
 
    elif(Dir == 1):
        if (not isBlocked(matrix, i + 1, j)):
            nxt_i += 1
        else:
            nxt_dir = 2
            nxt_j -= 1
 
    elif(Dir == 2):
        if (not isBlocked(matrix, i, j - 1)):
            nxt_j -= 1
        else:
            nxt_dir = 3
            nxt_i -= 1
 
    elif(Dir == 3):
        if (not isBlocked(matrix, i - 1, j)):
            nxt_i -= 1
        else:
            nxt_dir = 0
            nxt_j += 1
 
    spirallyDFSTravserse(matrix, nxt_i, nxt_j, nxt_dir, res)
 
# To traverse spirally
 
 
def spirallyTraverse(matrix):
    res = []
    spirallyDFSTravserse(matrix, 0, 0, 0, res)
    return res
 
 
# Driver code
a = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
 
# Function Call
res = spirallyTraverse(a)
print(*res)
 
# This code is contributed by rag2127

C＃

using System;
using System.Collections.Generic;
 
class GFG {
 
    public static int R = 4, C = 4;
    public static bool isInBounds(int i, int j)
    {
        if (i < 0 || i >= R || j < 0 || j >= C)
            return false;
 
        return true;
    }
 
    // Check if the position is blocked
    public static bool isBlocked(int[, ] matrix, int i,
                                 int j)
    {
        if (!isInBounds(i, j))
            return true;
        if (matrix[i, j] == -1)
            return true;
        return false;
    }
 
    // DFS code to traverse spirally
    public static void spirallyDFSTravserse(int[, ] matrix,
                                            int i, int j,
                                            int dir,
                                            List res)
    {
        if (isBlocked(matrix, i, j))
            return;
 
        bool allBlocked = true;
 
        for (int k = -1; k <= 1; k += 2) {
            allBlocked = allBlocked
                         && isBlocked(matrix, k + i, j)
                         && isBlocked(matrix, i, j + k);
        }
        res.Add(matrix[i, j]);
        matrix[i, j] = -1;
 
        if (allBlocked) {
            return;
        }
 
        // dir: 0 - right, 1 - down, 2 - left, 3 - up
        int nxt_i = i;
        int nxt_j = j;
        int nxt_dir = dir;
        if (dir == 0) {
            if (!isBlocked(matrix, i, j + 1)) {
                nxt_j++;
            }
            else {
                nxt_dir = 1;
                nxt_i++;
            }
        }
        else if (dir == 1) {
            if (!isBlocked(matrix, i + 1, j)) {
                nxt_i++;
            }
            else {
                nxt_dir = 2;
                nxt_j--;
            }
        }
        else if (dir == 2) {
            if (!isBlocked(matrix, i, j - 1)) {
                nxt_j--;
            }
            else {
                nxt_dir = 3;
                nxt_i--;
            }
        }
        else if (dir == 3) {
            if (!isBlocked(matrix, i - 1, j)) {
                nxt_i--;
            }
            else {
                nxt_dir = 0;
                nxt_j++;
            }
        }
        spirallyDFSTravserse(matrix, nxt_i, nxt_j, nxt_dir,
                             res);
    }
 
    // To traverse spirally
    public static List spirallyTraverse(int[, ] matrix)
    {
        List res = new List();
        spirallyDFSTravserse(matrix, 0, 0, 0, res);
        return res;
    }
 
    // Driver code
    static public void Main()
    {
        int[, ] a = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 9, 10, 11, 12 },
                      { 13, 14, 15, 16 } };
 
        // Function Call
        List res = spirallyTraverse(a);
        int size = res.Count;
 
        for (int i = 0; i < size; ++i)
            Console.Write(res[i] + " ");
 
        Console.WriteLine();
    }
}
 
// This code is contributed by avanitrachhadiya2155

Javascript

 
var R = 4, C = 4;
function isInBounds(i, j)
{
    if (i < 0 || i >= R || j < 0 || j >= C)
        return false;
    return true;
}
// Check if the position is blocked
function isBlocked(matrix, i, j)
{
    if (!isInBounds(i, j))
        return true;
    if (matrix[i][j] == -1)
        return true;
    return false;
}
// DFS code to traverse spirally
function spirallyDFSTravserse(matrix, i, j, dir, res)
{
    if (isBlocked(matrix, i, j))
        return;
    var allBlocked = true;
    for (var k = -1; k <= 1; k += 2) {
        allBlocked = allBlocked
                     && isBlocked(matrix, k + i, j)
                     && isBlocked(matrix, i, j + k);
    }
    res.push(matrix[i][j]);
    matrix[i][j] = -1;
    if (allBlocked) {
        return;
    }
    // dir: 0 - right, 1 - down, 2 - left, 3 - up
    var nxt_i = i;
    var nxt_j = j;
    var nxt_dir = dir;
    if (dir == 0) {
        if (!isBlocked(matrix, i, j + 1)) {
            nxt_j++;
        }
        else {
            nxt_dir = 1;
            nxt_i++;
        }
    }
    else if (dir == 1) {
        if (!isBlocked(matrix, i + 1, j)) {
            nxt_i++;
        }
        else {
            nxt_dir = 2;
            nxt_j--;
        }
    }
    else if (dir == 2) {
        if (!isBlocked(matrix, i, j - 1)) {
            nxt_j--;
        }
        else {
            nxt_dir = 3;
            nxt_i--;
        }
    }
    else if (dir == 3) {
        if (!isBlocked(matrix, i - 1, j)) {
            nxt_i--;
        }
        else {
            nxt_dir = 0;
            nxt_j++;
        }
    }
    spirallyDFSTravserse(matrix, nxt_i, nxt_j, nxt_dir,
                         res);
}
// To traverse spirally
function spirallyTraverse(matrix)
{
    var res = [];
    spirallyDFSTravserse(matrix, 0, 0, 0, res);
    return res;
}
// Driver code
var a = [ [ 1, 2, 3, 4 ],
              [ 5, 6, 7, 8 ],
              [ 9, 10, 11, 12 ],
              [ 13, 14, 15, 16 ]];
// Function Call
var res = spirallyTraverse(a);
var size = res.length;
for (var i = 0; i < size; ++i)
    document.write(res[i] + " ");
 

输出

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

复杂性分析：

时间复杂度：O(m*n)。遍历矩阵需要 O(m*n) 时间。
辅助空间：O(1)。不需要额外的空间（不考虑递归使用的堆栈）。

• 矩阵的对角线遍历
• 以反螺旋形式打印矩阵
• 以之字形形式打印给定的矩阵