广度优先搜索迷宫路径算法的实现

#include "stdio.h" 

#define COL 10

#define ROW 10

#define BOOL int

#define TRUE 1

#define FALSE 0

typedef struct plot

{

        int col;

        int row;

}Plot;

int Maze[COL][ROW] = {     {1,1,1,1,1,1,1,1,1,1},

                                             {0,0,0,0,0,0,1,0,0,1},

                                             {1,1,0,1,1,0,1,0,1,1},

                                            {1,1,0,1,0,0,0,0,0,1},

                                             {1,0,0,1,1,0,1,1,0,1},

                                             {1,0,1,0,0,0,1,1,1,1},

                                             {1,0,1,0,1,1,0,0,0,1},

                                             {1,0,1,0,1,1,0,1,0,1},

                                             {1,0,1,0,0,0,0,1,0,0},

                                            {1,1,1,1,1,1,1,1,1,1}};

int head = 0, rear = 0;

int level = 2;

Plot flag_queue[COL * ROW];

void get_path(int x, int y);

void width_flag(int x, int y);

void en_queue(int x, int y);

void out_queue();

BOOL queue_not_empty();

void print_path();

void print_maze();

int main()

{

        width_flag(8, 9);

          get_path(1, 0);

          print_path();

          print_maze();

          return 0;

}

void get_path(int x, int y)

{

          int i = 0;

          level = Maze[x][y];

          while(level>1)

          {

                    flag_queue[i].col = x;

                    flag_queue[i].row = y;

                    i++;

                    level--;

                    if(x>0 && Maze[x-1][y]==level)

                            x--;

                    else if(y+1

                            y++;

                    else if(x+1

                             x++;

                    else

                            y--;

          }

          level = i;

}

void width_flag(int x, int y)

{

          en_queue(x, y);

          while(queue_not_empty())

          {

                    x = flag_queue[head].col;

                    y = flag_queue[head].row;

                    level = Maze[x][y] + 1;

                    if(x>0 && Maze[x-1][y]==0)

                           en_queue(x-1, y);

                    if(y+1

                            en_queue(x, y+1);

                    if(x+1

                            en_queue(x+1, y);

                    if(y>0 && Maze[x][y-1]==0)

                             en_queue(x, y-1);

                    out_queue();

          }

}

void en_queue(int x, int y)

{

          Maze[x][y] = level;

          flag_queue[rear % (COL * ROW)].col = x;

          flag_queue[rear % (COL * ROW)].row = y;

          rear = (rear + 1) % (COL * ROW);

}

void out_queue()

{

          head = (head + 1) % (COL * ROW);

}

BOOL queue_not_empty()

{

          if(head==rear) 

                    return FALSE;

          else

                    return TRUE;

}

void print_path()

{

          int i;

          printf("\nStart->");

          for(i=0; i

                    printf("(%d,%d)->", flag_queue[i].col, flag_queue[i].row);

          printf("end\n\n");

}

void print_maze()

{

          int i,j;

          for(i=0; i

          {

                    for(j=0; j

                             printf("=",Maze[i][j]);

                    printf("\n");

         }

}