leetcode54、螺旋矩阵

题目描述：

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

示例 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]

解题思路：

采用深度优先算法（或者回溯，我也不知道该叫啥，反正就是递归，归就完了），回溯过程用哈希表（最近贼喜欢哈希表，哈希yyds）保存，首先向右递归，到头或者检测到重复时，方向改为下，到头或者检测到重复，方向改为左，然后改为上，然后改为右········

执行用时：0 ms, 在所有 C 提交中击败了100.00%的用户

内存消耗：5.6 MB, 在所有 C 提交中击败了74.14%的用户

bool dfs(int** matrix,int matrixSize,int*matrixColSize,int*returnSize,int* res,int**HashTable,int row,int col,int flag){
    if(row>=matrixSize||row<0)return false;//超过边界就返回
    if(col>=*matrixColSize||col<0)return false;
    if(HashTable[row][col]==1)return false;//重复遍历就返回
    res[(*returnSize)++] = matrix[row][col];//遍历结果保存到数组中
    HashTable[row][col]=1;//哈希表记录路径
    switch(flag){
        case 1://向右遍历
            if(dfs(matrix,matrixSize,matrixColSize,returnSize,res,HashTable,row,col+1,flag)==false){//如果向右遍历出错，则改为向下遍历
                flag=2;
                if(dfs(matrix,matrixSize,matrixColSize,returnSize,res,HashTable,row+1,col,flag)==false)return false;//如果向下遍历也出错，那么就返回（这里注意一点，向右的遍历只能改为向下，不能改为其他方向）
            }
            break;
        case 2:
            if(dfs(matrix,matrixSize,matrixColSize,returnSize,res,HashTable,row+1,col,flag)==false){//如果向下遍历出错，则改为向左遍历
                flag=3;
                if(dfs(matrix,matrixSize,matrixColSize,returnSize,res,HashTable,row,col-1,flag)==false)return false;//如果向左遍历也出错，那么就返回（这里注意一点，向下的遍历只能改为向左，不能改为其他方向）
            }
            break;
        case 3:
            if(dfs(matrix,matrixSize,matrixColSize,returnSize,res,HashTable,row,col-1,flag)==false){//如果向左遍历出错，则改为向上遍历
                flag=4;
                if(dfs(matrix,matrixSize,matrixColSize,returnSize,res,HashTable,row-1,col,flag)==false)return false;
            }
            break;
        case 4:
            if(dfs(matrix,matrixSize,matrixColSize,returnSize,res,HashTable,row-1,col,flag)==false){//如果向上遍历出错，则改为向右遍历
                flag=1;
                if(dfs(matrix,matrixSize,matrixColSize,returnSize,res,HashTable,row,col+1,flag)==false)return false;
            }
            break;
    }
   
    return true;
}
int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, int* returnSize){
    int** HashTable = (int**)malloc(sizeof(int*)*matrixSize);
    int* res = (int*)malloc(sizeof(int)*(*matrixColSize)*(matrixSize));
    *returnSize=0;
    for(int i=0;i<matrixSize;i++){
        HashTable[i] = (int*)malloc(sizeof(int)*(*matrixColSize));
        bzero(HashTable[i],sizeof(int)*(*matrixColSize));
    }
    dfs(matrix,matrixSize,matrixColSize,returnSize,res,HashTable,0,0,1);
    return res;
}