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

#include"stdio.h" 

#define COL 10

#define ROW 10

#define BOOL int

#define TRUE 1

#define FALSE 0

typedef struct plot

{

       intcol;

       introw;

}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");

       }

}