走迷宫_BFS

昨天刚接触BFS算法，用的queue队列，算法的理解应该没什么问题，但是BFS和DFS在输出最短的路径上有点不一样，BFS如果要输出路径就必须要做记录，然后在逆向DFS，我用的是逆向链表记录路径，队列弹出推入的都是结构体地址。

/*
  Name: 老鼠走迷宫（二） BFS
  Copyright: 
  Author: 顾骏 
  Date: 23/05/13 22:14
  Description: BFS
*/
#include <stdio.h>
#include <stdlib.h>
#include <queue>
#include <windows.h>
using namespace std;

typedef struct node
{
   int x;
   int y;
   int move;
   struct node* last;
}point;
point start={1,1,0,NULL},end={7,7};

void visit(void);
int maze[9][9]={
                  {2,2,2,2,2,2,2,2,2},
                  {2,0,0,0,0,0,0,0,2},
                  {2,0,2,2,0,2,2,0,2},
                  {2,0,2,0,0,2,0,0,2},
                  {2,0,2,0,2,0,2,0,2},
                  {2,0,0,0,0,0,2,0,2},
                  {2,2,0,2,2,0,2,2,2},
                  {2,0,0,0,0,0,0,0,2},
                  {2,2,2,2,2,2,2,2,2}
               },
   dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};

int main()
{
   int i,j;
   printf("Show:\n");
   for(i=0;i<9;i++)
   {
      for(j=0;j<9;j++)
         {
            if(maze[i][j]==2)
               printf("■"); 
            else
               printf("  ");
         }
      printf("\n");
   }
   visit();
   system("pause");
   return 0;
}

void visit(void)
{
   queue<point*> p,p_free;
   p.push(&start);
   point* temp;
   while(!p.empty())
      {
         temp=p.front();
         p.pop();
         for(int i=0;i<4;i++)
            {
               point* next=(point*)malloc(sizeof(point));
               p_free.push(next);
               next->last=temp;
               next->x=temp->x+dir[i][0];
               next->y=temp->y+dir[i][1];
               
               if(maze[next->x][next->y]==0)
                  {
                     next->move=temp->move+1;
                     maze[next->x][next->y]=1;
                     
                     if(next->x==end.x&&next->y==end.y)
                        {  
                           //回溯出路径 
                           for(point* q=next;q!=NULL;q=q->last)
                              {
                                 maze[q->x][q->y]=3;
                              }
                           //输出路径 
                           printf("\nmove:%d\n",next->move);
                           for(int j=0;j<9;j++)
                              {
                                 for(int k=0;k<9;k++)
                                    {
                                       if(maze[j][k]==2)
                                          printf("■");
                                       else if(maze[j][k]==3)
                                          printf("◇");
                                       else
                                          printf("  ");
                                    }
                                 printf("\n");
                              }
                           //释放内存
                           while(!p_free.empty())
                              {
                                 temp=p_free.front();
                                 free(temp);
                                 p_free.pop();
                              }
                           return;
                        }
                     p.push(next);
                  }
            } 
      }
}