深度优先和广度优先

渣渣编程bug多,调来调去一上午

//
// Created by dgm on 19-3-27.
//
#include <iostream>
using namespace std;
typedef int VertexType; //边的长度,本例全部输入1
typedef int VRType;     //节点编号
typedef char* Info;     //附加信息
#define MaxNum 100
#define Infinity 65535
typedef struct {        //邻接矩阵
    VertexType adj=Infinity;
    Info info;
}ArcCell,GMatrix[MaxNum][MaxNum];

typedef struct {
    GMatrix arcs;
    VRType vexs[MaxNum];
    unsigned arcnum,vexnum;
}MGraph;

void CreateGraph(MGraph&G)
{
    cout<<"vexnum&arcnum"<<endl;
    cin>>G.vexnum>>G.arcnum;
    cout<<"vexs"<<endl;
    for (int i = 0; i < G.vexnum; ++i) cin>>G.vexs[i];
    cout<<"arcs"<<endl;
    int posx,posy;
    VertexType weight;
    for (int i = 0; i < G.arcnum; ++i) {
        cin>>posx>>posy>>weight;
        for (int j = 0; j < G.vexnum; ++j) {    //这里是为了找到节点在G.vexs中的位置
            if (G.vexs[j]==posx)posx=j;         //因为输入的节点的编号不一定是其在G.vexs中的位置
            if (G.vexs[j]==posy)posy=j;         //例如节点从1开始编号,而vexs从下标0开始存储
        }
        G.arcs[posx][posy].adj=G.arcs[posy][posx].adj=weight; //注意对称位置也要赋值
    }
}

int FirstAdjVex(MGraph G,int u)       //找到与G.vexs[u]节点之间有边的第一个节点
{
    for (int i = 0; i < G.vexnum; ++i)
        if(G.arcs[u][i].adj!=Infinity)
            return i;
    return -1;
}

int NextAdjVex(MGraph G,int u,int w)  //找到与G.vexs[u]节点之间有边的并且在G.vexs[w]之后的节点
{
    for (int i = w+1; i < G.vexnum; ++i)
        if(G.arcs[u][i].adj!=Infinity)
            return i;
    return -1;
}

int visited[MaxNum];        //遍历时,用于标记节点是否已经被访问过

void DFS(MGraph G,int u)    //深度优先
                            //在递归的过程中,参数u的值一直在变,
                            //因此,可以找到与G.vexs[u]之间有路径的所有节点
{
    visited[u]=1;
    cout<<G.vexs[u]<<" ";
    for (int i = FirstAdjVex(G,u); i >=0 ; i=NextAdjVex(G,u,i))
        if (!visited[i])DFS(G,i);
}

void DFSTraverse(MGraph G)   //应对G不是连通图的情况
                             //如果G是连通图,只用DFS就可以全部遍历
{
    for (int i = 0; i < G.vexnum; ++i) visited[i]=0;
    for (int i = 0; i < G.vexnum; ++i)
        if(!visited[i])DFS(G,i);
}

typedef  struct Node{
    int vex;
    Node* next;
}Node,*QNode;

typedef struct {        //广度遍历要用到队列
    QNode front;
    QNode rear;
}Queue;

void InitQueue(Queue&Q)
{
    Q.front=Q.rear=(QNode)malloc(sizeof(Node)); //注意:
                                                //因为Q.front指向一个空的Node,而不是直接指向被储存元素
                                                //所以第一个有效元素从Q.front->next开始存储
    Q.front->next=Q.rear->next=NULL;
}

void EnQueue(Queue&Q,VRType u)
{
    QNode q=(QNode)malloc(sizeof(Node));
    q->vex=u;
    Q.rear->next=q;
    Q.rear=q;
}

void DeQueue(Queue&Q,int &u)
{
    QNode p=Q.front;
    Q.front=Q.front->next;
    u=Q.front->vex;
    free(p);
}

bool EmptyQueue(Queue Q)
{
    return Q.front==Q.rear;
}
void BFSTraverse(MGraph G)
{
    Queue Q;
    int u;
    InitQueue(Q);
    for (int i = 0; i < G.vexnum; ++i) visited[i]=0;
    for (int i = 0; i < G.vexnum; ++i) {
        if(!visited[i])
        {
            visited[i]=1;
            EnQueue(Q,i);
            while(!EmptyQueue(Q))
            {
                DeQueue(Q,u);   //出队,并在接下来的for中,将G.vexs[u]的所有邻接顶点入队
                cout<<G.vexs[u]<<" ";
                for (int j = FirstAdjVex(G,u); j >=0 ; j=NextAdjVex(G,u,j)) {
                    if(!visited[j]){
                        visited[j]=1;
                        EnQueue(Q,j);
                    }
                }
            }

        }
    }
}
int main()
{
    MGraph G;
    CreateGraph(G);
    DFSTraverse(G);
    cout<<endl<<"*****************"<<endl;
    BFSTraverse(G);
    return 0;
}

在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值