c语言数据结构顺时针打印矩阵

int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, int* returnSize) {
    if (matrixSize == 0 || matrixColSize[0] == 0) {
        *returnSize = 0;
        return NULL;
    }

    int rows = matrixSize, columns = matrixColSize[0];
    int visited[rows][columns];
    memset(visited, 0, sizeof(visited));
    int total = rows * columns;
    int* order = malloc(sizeof(int) * total);
    *returnSize = total;

    int row = 0, column = 0;
    int directionIndex = 0;
    for (int i = 0; i < total; i++) {
        order[i] = matrix[row][column];
        visited[row][column] = true;
        int nextRow = row + directions[directionIndex][0], nextColumn = column + directions[directionIndex][1];
        if (nextRow < 0 || nextRow >= rows || nextColumn < 0 || nextColumn >= columns || visited[nextRow][nextColumn]) {
            directionIndex = (directionIndex + 1) % 4;
        }
        row += directions[directionIndex][0];
        column += directions[directionIndex][1];
    }
    return order;
}

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

1.. 第一步定义 int directions[4][2]，从中定义4个数组，这是什么意思呢
2. 假设已经把矩阵第一个数字给到了要存放数据的order数组中，这个int nextRow与int nextColumn是行数列数加一嘛

#include <stdio.h>
#include <stdlib.h>

int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, int* returnSize) {
    if (matrixSize == 0 || matrixColSize[0] == 0) {
        *returnSize = 0;
        return NULL; 
    }
    
    int rows = matrixSize, columns = matrixColSize[0];
    int* order = malloc(rows * columns * sizeof(int));
    *returnSize = rows * columns;
    
    int row = 0, column = 0; 
    int directionIndex = 0; 
    for (int i = 0; i < rows * columns; i++) {
        order[i] = matrix[row][column];
        matrix[row][column] = 0; 
        
        int nextRow = row + directions[directionIndex][0], 
            nextColumn = column + directions[directionIndex][1];
        if (nextRow < 0 || nextRow >= rows || nextColumn < 0 || nextColumn >= columns || matrix[nextRow][nextColumn] == 0) 
            directionIndex = (directionIndex + 1) % 4;
        
        row += directions[directionIndex][0];
        column += directions[directionIndex][1];
    }
        
    return order;
}

int main() {
    int **matrix = malloc(3 * sizeof(int*));
    for (int i = 0; i < 3; i++) {
        matrix[i] = malloc(4 * sizeof(int));
    }
    
    matrix[0][0] = 1; matrix[0][1] = 2; matrix[0][2] = 3; matrix[0][3] = 4;
    matrix[1][0] = 5; matrix[1][1] = 6; matrix[1][2] = 7; matrix[1][3] = 8;
    matrix[2][0] = 9; matrix[2][1] = 10; matrix[2][2] = 11; matrix[2][3] = 12;
    
    int matrixSize = 3, matrixColSize[] = {4};
    int returnSize;
    int* order = spiralOrder(matrix, matrixSize, matrixColSize, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", order[i]);
    }
}

程序定义了方向数组directions,实现了spirlaOrder函数按照顺时针顺序打印矩阵,并在main函数中测试了3×4的矩阵。
spirlaOrder函数通过矩阵大小初始化order数组,然后根据方向数组的指示移动行和列索引,打印对应元素并将其置0。当出现无法移动的情况时改变方向。
最终输出结果为:1 2 3 4 8 12 11 10 9 5 6 7

望采纳！

1 你可以把数组理解为坐标系 direction数组的设定就是方便你上下左右移动去存储元素
2 nextrow和nextcolumn是根据direction数组的移动进行行列数加一，输出打印后的元素置为0，当每行的元素都为0时 向下移动并且方向发生改变