⭐️前面的话⭐️

大家好！本篇文章将介绍关于数据结构之链表的OJ题，来自力扣：剑指 Offer 29. 顺时针打印矩阵（C语言）题解，展示代码语言暂时为：C语言。

📒博客主页：未见花闻的博客主页
🎉欢迎关注🔎点赞👍收藏⭐️留言📝
📌本文由未见花闻原创！
📆华为云首发时间：🌴2022年5月31日🌴
✉️坚持和努力一定能换来诗与远方！
💭参考书籍：📚《C语言程序设计》📚《剑指offer》
💬参考在线编程网站：🌐牛客网🌐力扣
博主的码云gitee，平常博主写的程序代码都在里面。
博主的github，平常博主写的程序代码都在里面。
🍭作者水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！

⭐️剑指 Offer 29. 顺时针打印矩阵（C语言）⭐️

🔐题目详情

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

示例：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
输入：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]

限制：

0 <= matrix.length <= 100
0 <= matrix[i].length <= 100

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shun-shi-zhen-da-yin-ju-zhen-lcof/

💡解题思路

方法： 在生活中，我相信大家一定都接触过卷心菜或者洋葱，它们都是由许多层叠加包起来的。不知道你们剥过洋葱或卷心菜没有，对于这道题我们可以一层一层地剥开，先外后里，一层一层地遍历完所有的元素。
首先，我们需要对最外层进行遍历，然后再进一层，直到遍历完所有的元素。而每一层的遍历我们可以拆成4个部分，由于每次都是从左上角开始，所以遍历次序依次为顶行 右列 底行 左列，这四部分的指针分别为up right down left：

1. 顶行遍历完，up++
2. 右列遍历完，right--
3. 底行遍历完，down--
4. 左列遍历完，left++

每这样循环一轮，就相当于剥了一层洋葱，当底行指针小于顶行指针或左列指针大于右列指针就代表已经全部遍历完。或者在遍历过程中，并进行计数，当计数个数与总元素个数相同时代表元素遍历完成！
假设数组总元素个数为size。

时间复杂度： O(size)
空间复杂度： O(1)

🔑源代码

编程语言：C语言
在线编程平台：力扣

//使用顶行不大于底行，左列不大于右列控制循环
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, int* returnSize){
    if (matrixSize == 0 || *matrixColSize == 0)
    {
        *returnSize = 0;
        return NULL;
    }

    int row = matrixSize;
    int col = *matrixColSize;
    int size = row*col;
    *returnSize = size;
    int* arr = (int*)malloc(sizeof(int) * size);
    int cnt = 0;//已经遍历的元素个数
    int left = 0, right = col - 1, up = 0, down = row - 1;//左右上下边界
    int i = 0;
    
    while (1)                           //cnt < size
    {
        for (i = left; cnt < size && i <= right; i++)
        {
            arr[cnt++] =  matrix[up][i];//打印上边界元素
        }
        //up++;
        if (++up > down)
            break;
        for (i = up; cnt < size && i <= down; i++)
        {
            arr[cnt++] = matrix[i][right];//打印右边界元素
        }
        //right--;
        if (--right < left)
            break;
        for (i = right; cnt < size && i >= left; i--)
        {
            arr[cnt++] = matrix[down][i];//打印下边界元素
        }
        //down--;
        if (--down < up)
            break;
        for (i = down; cnt < size && i >= up; i--)
        {
            arr[cnt++] = matrix[i][left];//打印左边界元素
        }
        //left++;
        if (++left > right)
            break;
    }
    return arr;
}

//使用遍历元素个数与数组总元素个数间的关系作为循环条件
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, int* returnSize){
    if (matrixSize == 0 || *matrixColSize == 0)
    {
        *returnSize = 0;
        return NULL;
    }

    int row = matrixSize;
    int col = *matrixColSize;
    int size = row*col;
    *returnSize = size;
    int* arr = (int*)malloc(sizeof(int) * size);
    int cnt = 0;//已经遍历的元素个数
    int left = 0, right = col - 1, up = 0, down = row - 1;//左右上下边界
    int i = 0;
    
    while (cnt < size)                           
    {
        for (i = left; cnt < size && i <= right; i++)
        {
            arr[cnt++] =  matrix[up][i];//打印上边界元素
        }
        up++;
        for (i = up; cnt < size && i <= down; i++)
        {
            arr[cnt++] = matrix[i][right];//打印右边界元素
        }
        right--;
        for (i = right; cnt < size && i >= left; i--)
        {
            arr[cnt++] = matrix[down][i];//打印下边界元素
        }
        down--;
        for (i = down; cnt < size && i >= up; i--)
        {
            arr[cnt++] = matrix[i][left];//打印左边界元素
        }
        left++;
    }
    return arr;
}

🌱总结

矩阵的顺时针或逆时针遍历，可以利用生活中剥洋葱或剥卷心菜的思想，一层一层地“剥开”矩阵。