数据结构与算法基础(王卓)(24):深度优先遍历算法DFS和广度优先遍历算法BFS

深度优先遍历算法DFS:

邻接矩阵:

#include
using namespace std;

typedef int Status;
#define MaxInt 999999  //表示无穷大
#define MVNum 100  //最大顶点数
//MAX Vertex Number
typedef char VertexType;  //设顶点类型:字符型
typedef int ArcType;  //设边的权值类型:int型

struct AMG
{
    VertexType vex[MVNum];  //顶点表
    ArcType arc[MVNum][MVNum];  //邻接矩阵
    int VexNum, ArcNum;  //(图)当前:顶点数和边数
};  //Adjacency Matrix Graph

//深度优先遍历算法(邻接矩阵)
int visited[MVNum] = {};    //未访问时元素全部为空

void DFS(AMG G, int v)
{
    int w;
    //访问第v个结点
    cout << G.vex[v]; //输出顶点内容
    //cout << v << endl;
    visited[v] = 1;
    //依次检查邻接矩阵v所在的行
    for (w = 0; w < G.VexNum; w++)
        //从邻接矩阵的第v行的第1个元素开始-遍历到该行第n个元素
    {
        if ((G.arc[v][w] != 0) && !visited[w])
            //相连且未被访问过
            DFS(G, w);
    }
        //算法时间复杂度O(n^2)
}

int main()
{

}

邻接表:

一开始我写的(第一版):

void DFS(ALG G, int v)
{
    int w,i=0;
    ArcNode* p=G.vex->firstarc;
    //访问第v个结点
    while (i < v)
    {
        p = p->nextarc;
        i++;
    }
    cout << p->adjvex; //输出顶点内容位置
    visited[v] = 1;
    //依次检查邻接矩阵v所在的行
    for (w = 0; w < G.vexnum; w++)
        //从邻接矩阵的第v行的第1个元素开始-遍历到该行第n个元素
    {
        p = p->nextarc;
        if ((p->adjvex) && !visited[w])
//        if ((G.vex[v][w] != 0) && !visited[w])
            //相连且未被访问过
            DFS(G, w);
    }  
}

这里,我们犯(陷入)了许多个逻辑错误

问题:

(1):

我们写的函数:在一开始指向的,并不是第 i 个顶点,而是第一个顶点的第 i 个元素

更何况我们第一步要输出的,是一个顶点,而非一个边结点

(2):

在最后的判断语句最好还是新设立一个指针变量,要不然后面我感觉p容易变混乱了

 哈哈哈扯淡的,后面其实根本不需要这个玩意 


最终成品:

//深度优先遍历算法
int visited[MVNum] = {};    //未访问时元素全部为空
void DFS(ALG G, int v)
{
    int w,i=0;
    cout << G.vex[v].data; 
    visited[v] = 1;
    ArcNode* p = G.vex[v].firstarc;
    while (p != NULL)
    {
        if (visited[p->adjvex] != 0)
            DFS(G,p->adjvex);
        p = p->nextarc;
    }
}

By the way,复习一下链表【取第i个元素】:

Status 取第i个元素(LinkList L, int i, Elemtype e)
{// GetElem“i”
    LinkList p;
    p = L->next;
    int j = 1;
    while (p && i > j)
    {
        p = p->next;
        j++;
    }
    if (i < 0 || i < j || !p)
        return false;
    e = p->data;
    return true;
}


广度优先遍历算法BFS

breadth:宽度;(知识、兴趣等的)广泛

邻接表:


我写的:

int visited[MVNum] = {};    
void BFS(ALG G, int v)
{
    cout << G.vex[v].data;
    visited[v] = 1;
    SqQueue Q;
    InitQueue(Q);
    EnQueue(Q, G.vex[v].firstarc->adjvex);//从第一个顶点开始遍历
    auto i = G.vex[v].firstarc;//指向(代表)链头
    while (!QueneEmpty(Q))//直至队空结束
    {
        auto j = i;//用于指向访问各个元素节点
        while (j != NULL)//当结点为空(链尾,结束了)结束循环
        {
            if (visited[j->adjvex] == 0)//入队【没被访问过的】元素
            {
                EnQueue(Q, j->adjvex);
            }
            j = j->nextarc;//指向下一轮循环
            visited[j->adjvex] = 1;//别忘了
        }
        DeQueue(Q, i->adjvex);//出队队头
        cout << j->adjvex;
        //输出出队的元素,当然这里出队和输出在循环开始时操作也可以
    }
}

详细学习过程以及整个过程中所有踩的坑,详见:

数据结构与算法基础(王卓)(24)附:邻接表的广度优先遍历算法BFS(学习过程记录)_宇 -Yu的博客-CSDN博客


邻接矩阵:

void BFS(AMG& G)
{
    for (int v = 0; v < G.VexNum; ++v)
    {
        for (int w = 0; w < G.VexNum; ++w)
        {
            if ((G.arc[v][w] != 0) && visited[w] == 0)
            {
                cout << G.vex[w];
                visited[w] = 1;
            }
        }
    }
    //算法时间复杂度O(n^2)
}

我感觉这个写的就是逐个访问输出

不过也无所谓了,这玩意不是很重要,而且总归是能写的

你可能感兴趣的:(算法,深度优先,宽度优先)