c语言用链表实现七巧板，并且自动判定游戏是否结束

实现七巧板需要使用链表数据结构，可以用一个结构体来表示每个块的形状，位置和状态。同时需要定义一个链表节点结构体，来存储每个块的信息。

下面是一个示例代码，可以实现七巧板的游戏和自动判定游戏是否结束：

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

#define MAX_ROW 5   // 七巧板所在的二维平面最大行数
#define MAX_COL 4   // 七巧板所在的二维平面最大列数
#define MAX_BLOCK 7 // 七巧板的块数

// 定义七巧板块的形状
char shapes[MAX_BLOCK][MAX_ROW][MAX_COL+1] = {
        {
            "****",
            "",
            "",
            ""
        },
        {
            "**",
            "**",
            "",
            ""
        },
        {
            "***",
            "*",
            "",
            ""
        },
        {
            "**",
            "**",
            " ",
            ""
        },
        {
            "****",
            "  *",
            "",
            ""
        },
        {
            "***",
            "**",
            "",
            ""
        },
        {
            " **",
            "** ",
            "",
            ""
        }
};

// 定义七巧板块的颜色
char colors[MAX_BLOCK] = {'R', 'G', 'B', 'Y', 'M', 'C', 'K'};

// 定义坐标结构体
struct Point{
    int x;
    int y;
};

// 定义七巧板块结构体
struct Block{
    char shape[MAX_ROW][MAX_COL+1];
    char color;
    struct Point pos;
    int state;
};

// 定义链表节点结构体
struct Node{
    struct Block block;
    struct Node* next;
};

// 定义函数原型
void print_board(char board[MAX_ROW][MAX_COL+1]);
int check_board(struct Node* head, char board[MAX_ROW][MAX_COL+1]);
void insert_node(struct Node** head, struct Block block);
void remove_node(struct Node** head, struct Block block);
int is_valid_pos(char board[MAX_ROW][MAX_COL+1], struct Block block);
int is_game_over(struct Node* head, char board[MAX_ROW][MAX_COL+1]);

int main(){
    char board[MAX_ROW][MAX_COL+1]; // 定义七巧板所在的二维平面
    struct Node* head = NULL;       // 定义链表头指针
    int i, j;
    // 初始化七巧板所在的二维平面
    for(i=0; i<MAX_ROW; i++){
        for(j=0; j<MAX_COL; j++){
            board[i][j] = ' ';
        }
        board[i][MAX_COL] = '\0';
    }
    // 插入所有的七巧板块
    for(i=0; i<MAX_BLOCK; i++){
        struct Block block;
        int row, col;
        for(row=0; row<MAX_ROW; row++){
            for(col=0; col<MAX_COL; col++){
                block.shape[row][col] = shapes[i][row][col];
            }
            block.shape[row][MAX_COL] = '\0';
        }
        block.color = colors[i];
        block.pos.x = 0;
        block.pos.y = 0;
        block.state = 0;
        insert_node(&head, block);
    }
    // 开始游戏
    while(!is_game_over(head, board)){
        struct Node* p = head;
        while(p){
            // 尝试移动当前块到所有合法位置
            int state = p->block.state;
            while(is_valid_pos(board, p->block)){
                p->block.state++;
                if(check_board(head, board)){
                    break;
                }
            }
            if(p->block.state == state){
                // 当前块无法移动，尝试移除当前块
                remove_node(&head, p->block);
                p = head;
            }else{
                // 当前块移动成功，继续下一块
                p = p->next;
            }
        }
        // 打印当前游戏状态
        print_board(board);
    }
    printf("Game over!\n");
    return 0;
}

// 打印七巧板所在的二维平面
void print_board(char board[MAX_ROW][MAX_COL+1]){
    int i;
    for(i=0; i<MAX_ROW; i++){
        printf("%s\n", board[i]);
    }
    printf("\n");
}

// 判断当前游戏是否结束
int is_game_over(struct Node* head, char board[MAX_ROW][MAX_COL+1]){
    struct Node* p = head;
    while(p){
        // 尝试移动当前块到所有合法位置
        int state = p->block.state;
        while(is_valid_pos(board, p->block)){
            p->block.state++;
            if(check_board(head, board)){
                break;
            }
        }
        if(p->block.state != state){
            // 当前块可以移动，游戏未结束
            return 0;
        }
        p = p->next;
    }
    // 所有块都无法移动，游戏结束
    return 1;
}

// 检查当前七巧板所在的二维平面是否合法
int check_board(struct Node* head, char board[MAX_ROW][MAX_COL+1]){
    int i, j;
    struct Node* p = head;
    while(p){
        // 检查当前块是否越界
        int row, col;
        for(row=0; row<MAX_ROW; row++){
            for(col=0; col<MAX_COL; col++){
                if(p->block.shape[row][col] == '*'){
                    int x = p->block.pos.x + row;
                    int y = p->block.pos.y + col;
                    if(x<0 || x>=MAX_ROW || y<0 || y>=MAX_COL){
                        return 0;
                    }
                }
            }
        }
        // 检查当前块是否与其他块重叠
        struct Node* q = head;
        while(q != p){
            int row, col;
            for(row=0; row<MAX_ROW; row++){
                for(col=0; col<MAX_COL; col++){
                    if(q->block.shape[row][col] == '*'){
                        int x1 = p->block.pos.x + row;
                        int y1 = p->block.pos.y + col;
                        int x2 = q->block.pos.x + row;
                        int y2 = q->block.pos.y + col;
                        if(x1 == x2 && y1 == y2){
                            return 0;
                        }
                    }
                }
            }
            q = q->next;
        }
        // 更新当前块的位置
        for(row=0; row<MAX_ROW; row++){
            for(col=0; col<MAX_COL; col++){
                if(p->block.shape[row][col] == '*'){
                    int x = p->block.pos.x + row;
                    int y = p->block.pos.y + col;
                    board[x][y] = p->block.color;
                }
            }
        }
        p = p->next;
    }
    return 1;
}

// 插入新的七巧板块到链表中
void insert_node(struct Node** head, struct Block block){
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->block = block;
    node->next = *head;
    *head = node;
}

// 从链表中移除指定的七巧板块
void remove_node(struct Node** head, struct Block block){
    struct Node* p = *head;
    struct Node* prev = NULL;
    while(p){
        if(p->block.color == block.color){
            if(prev){
                prev->next = p->next;
            }else{
                *head = p->next;
            }
            free(p);
            break;
        }
        prev = p;
        p = p->next;
    }
}

// 判断当前块是否可以移动到所有合法位置
int is_valid_pos(char board[MAX_ROW][MAX_COL+1], struct Block block){
    int row, col;
    for(row=0; row<MAX_ROW; row++){
        for(col=0; col<MAX_COL; col++){
            int x = block.pos.x + row;
            int y = block.pos.y + col;
            if(block.shape[row][col] == '*' && (x<0 || x>=MAX_ROW || y<0 || y>=MAX_COL || board[x][y]!=' ')){
                return 0;
            }
        }
    }
    return 1;
}

这个程序可以实现七巧板的游戏和自动判定游戏是否结束。在游戏过程中，程序会尝试移动每个块到所有合法位置，如果当前块无法移动，则尝试移除当前块。当所有块都无法移动时，游戏结束。在检查七巧板所在的二维平面是否合法时，程序会检查每个块是否越界或者与其他块重叠。如果检查失败，则当前块无法移动。