[C语言][剑指offer篇]--顺时针打印矩阵(深度优先搜索&顺序遍历)

题目描述

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]

示例 2：
输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

---

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shun-shi-zhen-da-yin-ju-zhen-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

理清思路

方法一 DFS(深度优先搜索)

 深度优先搜索：

• 遍历的起点一般是第一个。(在此题中是(0,0))。
• 用一个类似位图的数组来标记访问过的节点位置。
• 用一个数组来保存访问过的节点数据。
• 合理选择递归终止条件。(在此题中是矩阵的边界)
• 走到一条路径尽头后，会原路返回，每返回一层会检查是否还有其他方向要走，若有，继续往这个方向走到尽头，再原路返回，依次类推，直到获得预期的所有数据。
• 最后重点注意递归的终止条件，极易引发数据越界访问。

方法二 顺序遍历

• 用一个类似位图的数组来标记访问过的节点位置。
• 关键在于遍历方向的控制和矩阵边界的判断。
• 退出循环的条件：当遍历的个数 等于 矩阵元素总个数。

代码实现

方法一 DFS

static int *bitmap;//位图
static int r_bound;
static int c_bound;

int in_matrix(int r,int c)
{
    if((r >= 0 && r < r_bound) && (c >= 0 && c < c_bound))
    {
        return 1;
    }
    else
    {
        return 0;
    }
    
}

void dfs(int row, int col, int direction,int** matrix,int* ans,int index)
{
    if(!in_matrix(row,col) || bitmap[row*c_bound+col])
    {
        return;
    }

    if(!bitmap[row*c_bound+col])
    {
        bitmap[row*c_bound+col] = 1;
        ans[index] = matrix[row][col];
        index++;
    }

    switch(direction)
    {
        case 1:
            dfs(row,col+1,1,matrix,ans,index);//向左
            break;
        case 2:
            dfs(row+1,col,2,matrix,ans,index);//向下
            break;
        case 3:
            dfs(row,col-1,3,matrix,ans,index);//向左
            break;
        case 4:
            dfs(row-1,col,4,matrix,ans,index);//向上
            break;
    }
    dfs(row,col+1,1,matrix,ans,index);
    dfs(row+1,col,2,matrix,ans,index);
    dfs(row,col-1,3,matrix,ans,index);
    dfs(row-1,col,4,matrix,ans,index);
}


int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, int* returnSize){

    int *ans;
    int i = 0;
    int total;

    if(matrix == NULL || matrixSize == 0)
    {
        *returnSize = 0;
        return NULL;
    }

    total = matrixSize*(*matrixColSize);

    ans = (int*)malloc(sizeof(int)*total);
    bitmap = (int*)malloc(sizeof(int)*total);

    memset(bitmap,0,sizeof(int)*total);

    r_bound = matrixSize;
    c_bound = (*matrixColSize);

    *returnSize = total;

    dfs(0,0,1,matrix,ans,0);

    return ans;

}

[感谢]：
https://leetcode-cn.com/problems/shun-shi-zhen-da-yin-ju-zhen-lcof/solution/mo-ao-sou-suo-dfs-by-moao-kgid/

方法二 顺序遍历矩阵

int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, int* returnSize){

    int row = 0;
    int col = 0;
    int next_row = 0;
    int next_col = 0;
    int *ans;
    int i = 0;
    int total;
    int index = 0;
    
    int direction[4][2] = {
        {0,1},//向右
        {1,0},//向下
        {0,-1},//向左
        {-1,0}//向上
    };

    if(matrix == NULL || matrixSize == 0)
    {
        *returnSize = 0;
        return NULL;
    }

    int bitmap[matrixSize][*matrixColSize];

    total = matrixSize*(*matrixColSize);
    ans = malloc(sizeof(int)*total);
    *returnSize = total;

    memset(bitmap,0,sizeof(bitmap));

    while(i < total)
    {
        ans[i] = matrix[row][col];
        bitmap[row][col] = 1;

        next_row = row + direction[index][0];
        next_col = col + direction[index][1];

        if(next_row < 0 || next_row >= matrixSize || next_col < 0 || next_col >= (*matrixColSize) || bitmap[next_row][next_col])
        {
            index = (index + 1) % 4;
        }

        row += direction[index][0];
        col += direction[index][1];

        i++;
    }

    return ans;

}