队列的应用——(一)广度优先搜索

在队列中，同样可以用于走迷宫，而且会出现一个与之前不同的情形。

代码如下：(C++)

myqueue.h

#include<stdio.h>
#include<stdlib.h>
struct Point
{
        int _x;
        int _y;
};
struct  Node
{
        Point data;
        Node* next;
};

struct Queue
{
        Node*front;
        Node*rear;
};

void initQueue(Queue*q);
bool enQueueEmpty(Queue*q);
void enQueue(Queue*q,Point ch);
Point deQueue(Queue*q);
void resetQueue(Queue*q);
void destroyQueue(Queue*q);

 

myqueue.cpp

跟队列动态实现一样，只是把char变量换成了Point

#include"myqueue.h"
void initQueue(Queue*q)
{
    q->front = q->rear = (Node*)malloc(sizeof(Node));
    q->front->next=NULL;
}
bool enQueueEmpty(Queue*q)
{
    return q->front==q->rear;
}
void enQueue(Queue*q,Point ch)
{
    Node*cur= (Node*)malloc(sizeof(Node));
    cur->data=ch;
    cur->next=NULL;

    q->rear->next=cur;
    q->rear=cur;
}
Point deQueue(Queue*q)
{
    Point ch = q->front->next->data;
    if(q->front->next == q->rear)
    {
        q->rear = q->front;
        free(q->front->next);
        q->front->next=NULL;
    }
    else
    {
        Node*t=q->front->next;
        q->front->next=t->next;
        free(t);
    }
    return ch;
}
void resetQueue(Queue*q)
{
    Node* head=q->front->next;
    q->front->next=NULL;
    q->rear=q->front;
    Node*t;
    while(head)
    {
        t=head->next;
        free(head);
        head=t;
    }
}
void destroyQueue(Queue*q)
{
    resetQueue(q);
    free(q->front);
}

main函数

#include <iostream>
#include"myqueue.h"
#include <windows.h>
#define MAXROW 10
#define MAXLINE 10
//宏定义把迷宫 长宽都定义成10
using namespace std;
Queue s;  //变成全局，方便调用

Point prePoint[MAXROW][MAXLINE];//创建一个二维坐标

int maze[MAXROW][MAXLINE] =     //这个函数跟之前栈走迷宫是一样的
{
    1,1,1,1,1,1,1,1,1,1,
    0,0,0,1,1,1,1,1,1,1,
    1,1,0,1,1,1,1,1,1,1,
    0,0,0,0,0,0,1,1,1,1,
    1,1,0,1,1,0,1,1,1,1,
    1,1,0,1,0,0,0,1,1,1,
    1,1,0,1,1,0,1,1,1,1,
    1,1,0,1,1,0,0,0,1,1,
    1,1,0,1,0,1,1,0,0,0,
    1,1,0,0,0,1,1,1,1,1,
};

void displyMaze()
{
    for(int i=0; i< MAXROW; i++)
    {
        for(int j=0; j<MAXLINE; j++)
        {
            if(maze[i][j] == 1) printf("%2s"," *");          //代表迷宫的墙
            else if(maze[i][j] == 2) printf("%2s"," #"); //代表走过的路，用#代表
            else printf("%2s"," ");                               //代表迷宫的路
        }
        putchar(10);
    }
    printf(" ====================\n");
}

void displayPrePoint()
{
    for(int i=0; i< MAXROW; i++)
    {
        for(int j=0; j<MAXLINE; j++)
        {
            printf(" (%2d,%2d) ",prePoint[i][j]);
        }
        putchar(10);
    }
    printf(" ====================\n");
}

void visit(int x,int y,Point lastP )
{
    Point p={x,y};
    enQueue(&s,p);
    prePoint[x][y]=lastP;  //这里存储的是上一步为已经出队的点
                                       //这样就形成了每个点都存储了上一个位置的点的二维数组
}

int main()
{
    Point sp={1,0},ep={8,9};//迷宫起点和终点（结构体只能这样初始化）

    memset(prePoint,0xff,sizeof(Point)*MAXLINE*MAXROW);

    initQueue(&s);
    enQueue(&s,sp);
    int flag=1;
#if 1
    while(!enQueueEmpty(&s))
    {
        Point t;
        t=deQueue(&s);       //弹出队列里存的点（这个点就是当前位置的点）
        maze[t._x][t._y]=2;   //表示走过的路，标记为 2

        system("cls");           //这是自动寻路刷新界面，然后有寻路动画
        displyMaze();
        Sleep(100);

        //竖是x轴. 横是y轴（数组的原理）
        //判断各方向的点能不能走，1.坐标从0开始 2.不能是死路 3.不能是走过的路
            //上
            if(t._x-1>=0&&maze[t._x-1][t._y] == 0)
                visit(t._x-1,t._y,t);     //这个 t 指的是移动前，自己原来出队的这个点
            //下
            if(t._x+1<=9&&maze[t._x+1][t._y] == 0)
                visit(t._x+1,t._y,t);
            //左
            if(t._y-1>=0&&maze[t._x][t._y-1] == 0)
                visit(t._x,t._y-1,t);
            //右
            if(t._y+1<=9&&maze[t._x][t._y+1] == 0)
                visit(t._x,t._y+1,t);

            if(t._x==ep._x&&t._y==ep._y)
            {
                flag=0;    //给定找到出口的标志位
                destroyQueue(&s);
                break;
            }
    }
#endif
    if(flag==0)
    {
          cout<<"find path"<<endl;
    }
    else
        cout<<"find no path"<<endl;
    displayPrePoint();

    Point t=ep;
    while(t._y!=-1)
    {
        printf(" (%d,%d) ",t._x,t._y);
        t=prePoint[t._x][t._y];
    }
    return 0;
}

现象是有岔路口时，分成几路同时走
在一条路走的时候，栈和队列本质也没有区别，都是入队一个，出队一个
有岔路的时候，就会发生几条路分别入队和出队，同步，一条路上一个入，一个出

广度优先搜索就是每条路都能同时走