c语言数独各个函数解析

谁知道这个数独代码的思路和里面各个函数的作用啊

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define ROW 9
#define COL 9
#define SIZE 9
#define CORRECT 0
#define WRONG -1 
#define MAXNUM 1000 
int checkSudoku(const char a[][COL]){
    int i,j,x,y;
    for( i = 0; i < ROW ; i++){
        for(j = 0 ; j < COL ; j++){        
            for(x = 0 ; x < COL ; x++)
                if(a[i][x] == a[i][j] && x != j ) 
                    return WRONG;
            
            for(x = 0 ; x < ROW ; x++)
                if(a[x][j] == a[i][j] && x != i ) 
                    return WRONG;
        
            for(x = i/3*3 ; x < i/3*3+3 ; x ++)
                for(y = j/3*3 ; y < j/3*3+3 ; y++)
                     if(a[x][y] == a[i][j] && (x != i && y != j)) 
                         return WRONG;         
        }    
    }
    return CORRECT;
}


void printSudoku(const char a[][COL]){
    int i,j;
    printf("\n ┌────┬────┬────┐\n"); 
    for( i = 0 ; i < ROW ; i++){
        if(i != 0 && i%3 == 0) printf(" ├────┼────┼────┤\n");
        printf(" │");
        for( j = 0 ; j < COL ; j++){
            if(j != 0 && j%3 == 0) printf("  │");
            if(a[i][j])
                printf(" %d",a[i][j]);
            else printf("  ");
        }
        printf("  │\n");
    }
    printf(" └────┴────┴────┘\n");
}


void readFromFile(char a[][COL], const char filename[]){
    // To Be Solved
    // 从文件filename中读取到的数独初盘存储到数组a[][COL]中
    FILE *file=fopen(filename,"r+");
    int i, j;
    for (i=0;i<ROW;i++)
    {
        for (j=0;j<COL;j++)
        {
            fscanf(file,"%d ",&a[i][j]);
        }
    }
    fclose(file);
    
}

int isValid(char b[][COL], int x, int y, int num)
{

    for (int i = 0; i < 9; i++)
    {
        if (b[x][i] == num || b[i][y] == num)
        {
            return 0;
        }
    }
    int startRow = (x / 3) * 3;
    int startCol = (y / 3) * 3;
    for (int i = startRow; i < startRow + 3; i++)
    {
        for (int j = startCol; j < startCol + 3; j++)
        {
            if (b[i][j] == num)
            {
                return 0;
            }
        }
    }
    return 1;
}

int solve(char b[][COL])
{
    for (int i=0;i<SIZE;i++)
    {
        for (int j=0;j<SIZE;j++)
        {
            if (b[i][j]==0) 
            {
                for (int num=1;num<=SIZE;num++)
                {
                    if (isValid(b,i,j,num))
                    {
                        b[i][j]=num; 
                        if (solve(b))
                        {
                            return 1;
                        }
                        b[i][j]=0;
                    }
                }
                return 0;
            }
        }
    }
    return 1;
}
int solveSudoku(const char a[][COL], char b[][COL]){
    // To Be Solved 
    // 参数const char a[][COL]表示初盘二维数组；
    // 参数char b[][COL]表示解的二维数组。 
    for (int i = 0;i<ROW;i++)
    {  
        for (int j=0;j<COL;j++)
        {
            b[i][j]=a[i][j];
        }
    }
    solve(b);
}
int main(){
    char starting_grid[ROW][COL]={0};
    char result[ROW][COL]={0};
    char filename[50];
    int rr;
    double time_from, time_to, time_sum = 0;
    int i;
    for(i=0;i<MAXNUM;i++){
        sprintf(filename,"D:\\二级项目\\数独\\sudoku\\%04d.txt",i);
        readFromFile(starting_grid,filename);
        printf("\n\n             *%4d  *",i);
        printSudoku(starting_grid);
        time_from = clock(); 
        solveSudoku(starting_grid,result);    
        time_to = clock();
        time_sum += time_to - time_from;    
        printSudoku(result);
        rr = checkSudoku(result);
        if( rr == WRONG){
            printf("Something goes wrong...\n");
            return WRONG;    
        } 
        else printf("            Correct!!!\n");
        printf("  ==============================");
    }
    printf("\n Congretulations! ToTal Time:%fs\n",time_sum / CLOCKS_PER_SEC);
    return 0;
}

• 帮你找了个相似的问题, 你可以看下: https://ask.csdn.net/questions/7613135
• 这篇博客也不错, 你可以看下C语言中字符函数与字符串函数的使用要点及模拟实现
• 你还可以看下c语言参考手册中的 c语言-字符串字面量
• 除此之外, 这篇博客: C语言结构体变量 指针以及对结构体成员的访问中的 结构体变量访问成员的方法 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
  

• int main(void)
  {
      struct STUDENT student1; /*用struct STUDENT结构体类型定义结构体变量student1*/
  
      student1.birthday.year = 1989;
      student1.birthday.month = 3;
      student1.birthday.day = 29;
      student1.num = 1207041;
      student1.score = 100;
  
      return 0;
  }
  

  访问方式：

  结构体变量.成员名

• 您还可以看一下 贺利坚老师的C语言及程序设计初步课程中的 数值型数据的存储小节, 巩固相关知识点
  

有用望采纳：
这段代码是一个解数独的程序，下面是代码中各个函数的作用和整体思路：

1. checkSudoku() 函数：

   • 作用：检查给定的数独是否符合数独的规则，即每一行、每一列、每个九宫格内是否有重复的数字。
   • 输入参数：二维字符数组 a，表示待检查的数独。
   • 返回值：如果数独符合规则，则返回 CORRECT（0），否则返回 WRONG（-1）。

2. printSudoku() 函数：

   • 作用：输出数独的当前状态，将数独以九宫格的形式打印到控制台。
   • 输入参数：二维字符数组 a，表示要打印的数独的状态。

3. readFromFile() 函数：

   • 作用：从文件中读取数独的初始状态，并将其存储到二维字符数组 a 中。
   • 输入参数：二维字符数组 a，表示用于存储数独的初始状态的数组；常量字符指针 filename，表示要读取的文件路径。
   • 文件格式：文件中按照数字的顺序以空格分隔每个数字，数字之间没有其他字符。

4. isValid() 函数：

   • 作用：检查在给定位置 (x,y) 上填入的数字 num 是否满足数独规则。
   • 输入参数：二维字符数组 b，表示当前数独的状态；整型变量 x 和 y，表示要检查的位置坐标；整型变量 num，表示要填入的数字。
   • 返回值：如果填入的数字满足数独规则，则返回 1，否则返回 0。

5. solve() 函数：

   • 作用：通过递归回溯的方式解决数独。
   • 输入参数：二维字符数组 b，表示当前数独的状态。
   • 返回值：如果成功找到数独的解，则返回 1，否则返回 0。

6. solveSudoku() 函数：

   • 作用：解数独的入口函数，负责初始化解的数组并调用 solve() 函数解决数独。
   • 输入参数：常量二维字符数组 a，表示数独的初始状态；二维字符数组 b，表示解的数组。
   • 解题过程：首先将初始状态的数独复制到解的数组中，然后调用 solve() 函数解决数独。

主函数 main() 的执行流程如下：

1. 创建存储初始数独和解的数组 starting_grid 和 result。
2. 循环测试一组数独，通过调用 readFromFile() 从文件中读取数独的初始状态到 starting_grid 中。
3. 打印当前数独的初始状态。
4. 记录当前时间，调用 solveSudoku() 解决数独，并记录解决数独的时间。
5. 打印解的结果。
6. 检查解的结果是否正确，如果正确则输出 "Correct!!!"，否则输出 "Something goes wrong..."。
7. 输出分隔线 "=============================="。
8. 循环进行下一组数独的测试。
9. 输出总时间。

综上所述，该代码实现了解决数独的功能，其中 solve() 函数使用了递归回溯算法来搜索数独的解，通过不断尝试填入数字并判断是否满足数独规则来逐步解决数独。