c语言队列实现迷宫算法

一、c语言广度搜索算法

1、环形队列实现

 

#include <stdio.h>
#define MAX_ROW 5
#define MAX_COL 5
/*利用队列方式来完成对一个迷宫数组进行深度搜索*/
int head = 0, tail = 0;
/*有一个5行，5列的数组,看成一个迷宫*/
int maze[MAX_ROW][MAX_COL] = {
        {0, 1, 0, 0, 0},
        {0, 1, 0, 1, 1},
        {0, 0, 0, 0, 0},
        {0, 1, 1, 1, 0},
        {0, 0, 0, 1, 0},
};

/*队列数组，每个单元都是一个point结构体*/
struct point{int row,col;} queue[512];

/*入栈*/
void enqueue(struct point per)
{
    if(tail == 512){
        tail = 0;
    }
    queue[tail++] = per;
}

/*出栈*/
struct point dequeue(void)
{
    if(head == 512){
        head = 0;
    }
    return queue[head++];
}

/*判断队列是否为空*/
int is_empty(void)
{
    return head == tail;
}

/*将当前搜索到的位置压入队列*/
void visit(int row, int col)
{
    struct point p = {row,col};
    //将搜索到的数组中的位置为0的地方标记为2一面进行2次搜索
    maze[row][col] = 2;
    enqueue(p);
}

/*打印每一步*/
void maze_print()
{
    int i, j;
    for(i=0; i<MAX_ROW; i++){
        for(j=0; j<MAX_COL; j++){
            printf("%d, ",maze[i][j]);
        }
        putchar('\n');
    }
    printf("**************\n");
}

int main(void)
{
    //初始化一个位置结构,并将起点设置为2
    struct point p = {0, 0};
    maze[p.row][p.col] = 2;
    //将起点压入栈中
    enqueue(p);
    while(!is_empty()){
        p = dequeue();
        if(p.row == MAX_ROW - 1 && p.col == MAX_COL - 1)
            break;                                      /*goal*/
        if(p.col + 1 < MAX_COL && maze[p.row][p.col+1] == 0)
            visit(p.row, p.col + 1);                    /*right*/
        if(p.row + 1 < MAX_ROW && maze[p.row+1][p.col] == 0)
            visit(p.row + 1, p.col);                    /*down*/
        if(p.col - 1 >= 0 && maze[p.row][p.col-1] == 0)
            visit(p.row, p.col - 1);                    /*left*/                                                                                                                
        if(p.row - 1 >= 0 && maze[p.row-1][p.col] == 0)
            visit(p.row - 1,p.col);                     /*top*/
        maze_print();
    }
    return 1;
}

二、c语言深度搜索算法

#include <stdio.h>
#define MAX_ROW 5
#define MAX_COL 5
/*利用队列方式来完成对一个迷宫数组进行深度搜索*/
int top = 0;
/*有一个5行，5列的数组,看成一个迷宫*/
int maze[MAX_ROW][MAX_COL] = {
        {0, 1, 0, 0, 0},
        {0, 1, 0, 1, 1},
        {0, 0, 0, 0, 0},
        {0, 1, 1, 1, 0},
        {0, 0, 0, 1, 0},
};

/*队列数组，每个单元都是一个point结构体*/
struct point{int row,col;} stack[512];

/*入栈*/
void push(struct point per)
{
    stack[top++] = per;
}

/*出栈*/
struct point pop(void)
{
    return stack[--top];
}

/*判断队列是否为空*/
int is_empty(void)
{
    return top == 0;
}

/*将当前搜索到的位置压入队列*/
void visit(int row, int col)
{
    struct point p = {row,col};
    //将搜索到的数组中的位置为0的地方标记为2一面进行2次搜索
    maze[row][col] = 2;
    push(p);
}

/*打印每一步*/
void maze_print()
{
    int i, j;
    for(i=0; i<MAX_ROW; i++){
        for(j=0; j<MAX_COL; j++){
            printf("%d, ",maze[i][j]);
        }
        putchar('\n');
    }
    printf("**************\n");
}

int main(void)
{
    //初始化一个位置结构,并将起点设置为2
    struct point p = {0, 0};
    maze[p.row][p.col] = 2;
    //将起点压入栈中
    push(p);
    while(!is_empty()){
        p = pop();
        if(p.row == MAX_ROW - 1 && p.col == MAX_COL - 1)
            break;                                      /*goal*/
        if(p.col + 1 < MAX_COL && maze[p.row][p.col+1] == 0)
            visit(p.row, p.col + 1);                    /*right*/
        if(p.row + 1 < MAX_ROW && maze[p.row+1][p.col] == 0)
            visit(p.row + 1, p.col);                    /*down*/
        if(p.col - 1 >= 0 && maze[p.row][p.col-1] == 0)
            visit(p.row, p.col - 1);                    /*left*/                                                                                                                
        if(p.row - 1 >= 0 && maze[p.row-1][p.col] == 0)
            visit(p.row - 1,p.col);                     /*top*/
        maze_print();
    }
    return 1;
}

 三、递归队列实现广度搜索

 

#include <stdio.h>
#define MAX_ROW 5
#define MAX_COL 5

/*利用队列方式来完成对一个迷宫数组进行深度搜索*/
int head = 0, tail = 0;
struct pos{int row,col;} queue[512];
struct pos p = {0, 0};
/*有一个5行，5列的数组,看成一个迷宫*/
int maze[MAX_ROW][MAX_COL] = {
        {0, 1, 0, 0, 0},
        {0, 1, 0, 1, 1},
        {0, 0, 0, 0, 0},
        {0, 1, 1, 1, 0},
        {0, 0, 0, 1, 0},
};

/*入栈*/
void enqueue(struct pos per)
{
    if(tail == 512){
        tail = 0;
    }
    queue[tail++] = per;
}

/*出栈*/
struct pos dequeue(void)
{
    if(head == 512){
        head = 0;
    }
    return queue[head++];
}

/*打印每一步*/
void maze_print()
{
    int i, j;
    for(i=0; i<MAX_ROW; i++){
        for(j=0; j<MAX_COL; j++){
            printf("%d, ",maze[i][j]);
        }
        putchar('\n');
    }
    printf("**************\n");
}

/*将当前搜索到的位置压入队列*/
void visit(int row, int col)
{
    struct pos pp = {row,col};
    //将搜索到的数组中的位置为0的地方标记为2一面进行2次搜索
    maze[row][col] = 2;
    enqueue(pp);
}

/*利用递归实现迷宫*/
void maze_recursive()
{
    p = dequeue();
    if(p.row == MAX_ROW - 1 && p.col == MAX_COL - 1)
        return;                                     /*goal*/
    if(p.col + 1 < MAX_COL && maze[p.row][p.col+1] == 0)
        visit(p.row, p.col + 1);                    /*right*/
    if(p.row + 1 < MAX_ROW && maze[p.row+1][p.col] == 0)
        visit(p.row + 1, p.col);                    /*down*/
    if(p.col - 1 >= 0 && maze[p.row][p.col-1] == 0)
        visit(p.row, p.col - 1);                    /*left*/                                                                                                                
    if(p.row - 1 >= 0 && maze[p.row-1][p.col] == 0)
        visit(p.row - 1,p.col);                     /*top*/
    maze_print();
    maze_recursive();
}

int main(void)
{
    maze[p.row][p.col] = 2;
    enqueue(p);
    maze_recursive();
    return 1;
}