无向有权图的建立(邻接链表法) 广度优先搜索 深度优先搜素

最新推荐文章于 2023-04-08 23:27:52 发布
最新推荐文章于 2023-04-08 23:27:52 发布
阅读量1.4k 收藏 8
点赞数 2
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43499703/article/details/90201130
版权 
/**图的邻接表存储方式*/

#include<iostream>
#include<cstdio>
#include<string.h>
#include<string>
#include<queue>

#define TRUE    1
#define FALSE   0
#define OK      1
#define ERROR   0

using namespace std;

#define MAX_VERTEX_NUM  100


#define MAXSIZE 100

typedef string VertexType;
typedef int    Status;
typedef int Element;

//队列的结点结构
typedef struct QNode{
    Element data;
    struct QNode * next;
}QNode;

//队列的链表结构
typedef struct{
    QNode * queue_front;  //队头指针
    QNode * queue_rear;   //队尾指针
}LinkQueue;


//链队的初始化
Status InitQueue(LinkQueue & Q)
{
    Q.queue_front=Q.queue_rear=(QNode *)malloc(sizeof(QNode));
    Q.queue_front->next=NULL;
    return OK;
}

//入队操作
Status EnQueue(LinkQueue & Q,Element e)
{
    QNode * p;
    p=(QNode*)malloc(sizeof(QNode));
    p->data=e;
    p->next=NULL;
    Q.queue_rear->next=p;
    Q.queue_rear=p;
    return OK;
}

//出队操作
Status Dequeue(LinkQueue & Q,Element & e)
{
    if(Q.queue_front==Q.queue_rear) return ERROR;
    QNode * p;
    p=Q.queue_front->next;      //p指向队头元素
    e=p->data;                  //e保存队头元素的值
    Q.queue_front->next=p->next;//修改头指针
    //注意的是：在链队出队操作时，如果最后一个元素被删除，队尾指针也丢失了，需要对队尾指针重新赋值
    if(Q.queue_rear==p)     Q.queue_rear=Q.queue_front;
    return e;
}

//遍历队列
Status QueueTraverse(LinkQueue Q)
{
    QNode * p;
    p=Q.queue_front->next;
    while(p)
    {
        cout<<(p->data)<<" ";
        p=p->next;
    }
    return OK;
}

//获取队头的元素
Status get_QueueHead(LinkQueue Q,Element & e)
{
    if(Q.queue_front==Q.queue_rear)
    {
        return ERROR;
    }
    else
    {
        e=Q.queue_front->next->data;
        return OK;
    }
}

/**判断队列是否为空*/
Status IsEmpty(LinkQueue Q)
{
    if(Q.queue_front==Q.queue_rear)
        return TRUE;
    else
        return FALSE;
}









queue<int>q;

bool visited[MAX_VERTEX_NUM]={0};
bool visited1[MAX_VERTEX_NUM]={0};

typedef struct Arcnode                  //弧
{
    /**该弧所指向的顶点的位置*/
    int adjvex;
    /**与边有关的信息(权值)*/
    int info;
    /**下一条以当前顶点为出度的弧*/
    struct Arcnode * nextarc;
}/**弧*/Arcnode;


typedef struct VNode                    //点
{
    /**结点名字*/
    VertexType data;
    /**指向第一条依附于该顶点的出边*/
    Arcnode * firstarc;
}/**点*/VNode,/**AdjList表示邻接表类型,点的集合*/AdjList[MAX_VERTEX_NUM];

typedef struct                          //图
{
    /**点的邻接表的数组*/
    AdjList vertices;
    /**图的当前顶点数*/
    int vexnum;
    /**图的当前边数*/
    int arcnum;
}/**图*/ALGraph;


/**加边*/
void ArcAdd(ALGraph &G,int v1,int v2,int w)     //加边
{
    Arcnode *p,*q;                              //Arcnode是弧

    p = new Arcnode;                            //新建立一个结点p
    p->adjvex=v2;                               //p边指向顶点位置为v2的那个顶点
    p->info=w;                                  //这条边的权重为w
    p->nextarc=NULL;                            //？
    q=G.vertices[v1].firstarc;                  //位置为v1这个点的第一条出边为q
    if(q==NULL)
    {
        G.vertices[v1].firstarc=p;  //若第一条依附v2顶点的弧还没有存在，则新加入的边作为第一条依附的弧

    }
    else                            //否则顺着链表向后查找
    {
        while(q->nextarc!=NULL)
            q=q->nextarc;
        q->nextarc=p;
    }

}

/**获取每个结点对应的存储位置标号*/
int LocateVex(ALGraph G,string name)
{
    for(int i=0;i<G.vexnum;i++)
    {
        if(name==G.vertices[i].data)
        {
            return i;
        }
    }
    return -1;
}

/**建立带权无向图*/
Status CreateUDN_2(ALGraph & G)
{
    cout<<"建立带权无向图，请依次输入总结点数，总边数：";
    cin>>G.vexnum>>G.arcnum;
    cout<<"请为从1至n个结点命名:"<<endl;
    for(int i=0;i<G.vexnum;i++)
    {
        cin>>G.vertices[i].data;
        G.vertices[i].firstarc=NULL;
    }
    string v1,v2;
    int w;
    cout<<"请输入"<<G.arcnum<<"组相互依附的两结点与边权"<<endl;
    for(int k=0;k<G.arcnum;k++)
    {
        cin>>v1>>v2>>w;
        int i=LocateVex(G,v1);
        int j=LocateVex(G,v2);
        ArcAdd(G,i,j,w);             //无向边
        ArcAdd(G,j,i,w);             //无向边
    }
    return OK;

}

/**第一个邻接点
*@return 返回值是v的第一个邻接点顶点的位置；若没有邻结点则返回为"空"
*/
int FirstAdjVex(ALGraph G,int v)
{
    if(G.vertices[v].firstarc)          //如果说对于点v，存在该点的一条出边
    {
        return G.vertices[v].firstarc->adjvex;      //返回v顶点的一条出边指向的那个顶点的位置
    }
    else
    {
        return -1;
    }
}

/**相对与某一点的下一个邻接点
*@return 返回值是v的（相对于w的）下一个邻接点；如果w是v的最后一个邻接点，则返回值为"空"
*/
int NextAdjVex(ALGraph G,int v,int w)
{
    Arcnode * p =G.vertices[v].firstarc;            //边p是顶点v的第一条出边
    while(p->adjvex!=w&&p->nextarc!=NULL)
    {
        p=p->nextarc;
    }
    if(p->nextarc==NULL)
    {
        return -1;
    }
    return p->nextarc->adjvex;
}

/**打印邻接表*/
void PrintGraph(ALGraph G)
{
    cout<<"图的创建完成，该图的邻接表表示如下："<<endl;
    cout<<"括号内表示边的权重——括号前面两个顶点组成边的权重,若权重为0表示没有权重"<<endl;
    Arcnode *p;                             //一条弧p
    for(int i=0;i<G.vexnum;i++)
    {
        if(G.vertices[i].firstarc==NULL)
        {
            cout<<i<<":  "<<G.vertices[i].data<<"-->NULL"<<endl;
        }
        else
        {
            p=G.vertices[i].firstarc;
            cout<<i<<":  "<<G.vertices[i].data<<"-->";
            while(p->nextarc!=NULL)
            {
                cout<<p->adjvex<<"("<<p->info<<")"<<"-->";
                p=p->nextarc;
            }
            cout<<p->adjvex<<"("<<p->info<<")"<<"-->NULL"<<endl;
        }
    }
}

/**深度优先搜索*/
void DFS(ALGraph G,int v)
{
    int w = 0;
    Arcnode * p = NULL;
    cout<<v;
    visited[v]=1;
    p=G.vertices[v].firstarc;
    while(p!=NULL)
    {
        w=p->adjvex;
        if(!visited[w])
        {
            DFS(G,w);
        }
        p=p->nextarc;
    }

}

/**广度优先搜索(使用标准库queue)*/
/*
void BFS(ALGraph G,int v)
{
    cout<<v;
    visited1[v]=1;
    q.push(v);
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        Arcnode * p;
        p=G.vertices[u].firstarc;
        while(p!=NULL)
        {
            if(!visited1[p->adjvex]){
                cout<<p->adjvex;
                visited1[p->adjvex]=1;
                q.push(p->adjvex);
            }
            p=p->nextarc;
        }
    }
}
*/

/**广度优先搜索(自己写的队列)*/
void BFS1(ALGraph G,int v)
{
    LinkQueue queue1;
    InitQueue(queue1);
    cout<<v;
    visited1[v]=1;
    EnQueue(queue1,v);
    while(!IsEmpty(queue1))
    {
        int u=0;
        //u = get_QueueHead(queue1,u);
        //Dequeue(queue1,u);
        u=Dequeue(queue1,u);
        Arcnode * p ;
        p=G.vertices[u].firstarc;
        while(p!=NULL)
        {
            if(!visited1[p->adjvex])
            {
                cout<<p->adjvex;
                visited1[p->adjvex]=1;
                EnQueue(queue1,p->adjvex);
            }
            p=p->nextarc;
        }
    }
}

int main()
{
    ALGraph G;
    CreateUDN_2(G);
    PrintGraph(G);
    cout<<"深度优先搜素遍历如下:"<<endl;
    DFS(G,0);
    cout<<"广度优先搜素遍历如下:"<<endl;
    BFS1(G,0);
    return 0;
}

注释还没写完，要考试了,唉…

参考两位大佬的资料，然后广度优先没用STL，用的自己之前写的链队
https://blog.csdn.net/kuronekonano/article/details/78657592 作者：kuronekonano
https://blog.csdn.net/Krismile_/article/details/84774256 作者：Krismile_

哈_哈，笑一个吧！
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
图深度优先和广度优先遍历
木木夕的博客
06-11 1976
实验目的    1. 深入了解图的逻辑结构特性及其基本操作    2. 了解图的各种存储结构的特点与适用范围，熟练掌握在邻接矩阵和邻接表存储结构上深度优先和广度优先搜索算法的实现    3. 掌握图的应用，如求解图的连通性问题，最小生成树，拓扑排序，关键路径和最短路径算法及其灵活应用实验预习    1. 深入了解图的邻接矩阵表示法与图的邻接矩阵表示法    2. 在实验预习报告上设计，编写实验内容...
数据结构：图
mxc111213_的博客
01-22 443
设计并验证如下算法：带权图采用邻接表表示，实现有向图的广度优先搜索与无向图的深度优先搜索。 #define MAX_VERTEX_NUM 20 //图的邻接表存储表示 typedef struct ArcNode{ int adjvex； //该弧所指向的顶点的位置 struct ArcNode *nextarc； //指向下一条弧的指针 InfoType *info； //该弧相关信息的指针 }ArcNode； typedef struct VNode { VertexType data；
无向图_C语言_
10-02
建立一无向图的邻接表存储结构，并构造其对应的深度优先搜索生成树或森林（该生成树或森林以孩子兄弟链表存储），按先序遍历该二叉链表，输出得到的序列。
带权图采用邻接表表示，实现无向图的广度优先搜索与有向图的深度优先搜索
槐殇雪的博客
12-24 5853
设计并验证如下算法：带权图采用邻接表表示，实现无向图的广度优先搜索与有向图的深度优先搜索。 #define MAX_VERTEX_NUM 20 //图的邻接表存储表示 typedef struct ArcNode{ int adjvex； //该弧所指向的顶点的位置 struct ArcNode *nextarc； //指向下一条弧的指针 InfoType *info； //该弧相关信息的指...
图的操作及应用（以邻接矩阵或邻接表方式建立无向图，并分别利用深度优先遍历和广度优先遍历方法输出各结点元素。）
weixin_52416700的博客
12-19 2364
主要运用： 1．图的邻接矩阵和邻接表存储结构； 2．图的深度优先遍历和广度优先遍历算法，复习栈和队列的应用； 3．图的最小生成树、最短路径等应用及算法思想。 实现功能：以邻接矩阵或邻接表方式建立无向图，并分别利用深度优先遍历和广度优先遍历方法输出各结点元素。 #include <iostream> typedef int ElemType; #define MaxSize 100 #define MAXVEX 100 #define INF 32767 typedef .
数据结构--图
qq_36047533的博客
04-22 655
数据结构--图 实现有向图、无向图、有权图、无权图的邻接矩阵和邻接表表示方法 实现图的深度优先搜索、广度优先搜索 实现 Dijkstra 算法、A* 算法 实现拓扑排序的 Kahn 算法、DFS 算法 对应的 LeetCode 练习题 Number of Islands（岛屿的个数） 英文版：https://leetcode.com/problems/number-of-islands/descr...
C++实现图的邻接矩阵存储和广度、深度优先遍历实例分析
09-03
本实例重点讨论了邻接矩阵的实现，并展示了如何进行广度优先遍历(BFS)和深度优先遍历(DFS)。邻接矩阵是一种二维数组，其中的每个元素表示图中两个节点之间是否存在边。如果节点i与节点j之间存在边，则邻接矩阵的[i]...
邻接矩阵存储图的深度优先遍历 邻接矩阵表示图-深度-广度优先遍历
最新发布
07-05
**深度优先遍历（DFS，Depth First Search）**是从一个顶点开始，尽可能深地探索图的分支，直到到达叶子节点或者回溯到没有未访问过的邻接点为止。在遍历过程中，可以通过访问标志数组`visited`来跟踪哪些顶点已经被...
tudebianli.rar_图的遍历_广度优先_深度优先搜索
09-24
在这个主题中，我们将深入探讨两种主要的遍历方法：深度优先搜索（DFS）和广度优先搜索（BFS）。这两个算法在计算机科学中有着广泛的应用，如网络爬虫、社交网络分析、游戏状态搜索等。 深度优先搜索（DFS）是一种...
C++实现图的邻接表存储和广度优先遍历实例分析
12-26
本文实例讲述了C++实现图的邻接表存储和广度优先遍历方法。分享给大家供大家参考。具体如下： 示例：建立如图所示的无向图 由上图知，该图有5个顶点，分别为a,b,c,d,e,有6条边. 示例输入（按照这个格式输入）： 5 6...
以邻接表邻接矩阵创建图，深度优先遍历与广度优先遍历
m0_54806993的博客
05-30 1429
参考其他博客，修改了一点点细节，没有过多简介，深度优先遍历和广度优先遍历过程可参考他人，附代码 #include<stdio.h> #include<stdlib.h> #include<malloc.h> #include<string.h> //邻接矩阵：基于数组->用一个一维数组存储顶点，用一个二位数组存储边 //邻接表：基于链表->用一个一维数组或者一个链表来存储所有顶点 #define max 100 #define coun
深度优先遍历
xlh006的博客
09-05 7042
1、深度优先搜索遍历过程 图的深度优先搜索(Depth First Search)，和树的先序遍历比较类似。 它的思想：假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和v有路径相通的顶点都被访问到。 若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被...
无向图&有向图的邻接表法建立
Koisky的博客
10-29 2704
无向图的邻接表法建立 要求建立一个无向图，采用邻接表做为存储结构。 例如： 输入信息为：第一行给出图的顶点数n和边数e。第二行给出n个字符，表示n个顶点的数据元素的值。后面是e行，给出每一条边的两个顶点编号。 7 9 ABCDEFG 0 1 0 2 0 6 1 3 1 4 2 5 2 6 3 4 3 6 输出每个顶点的值以及各顶点的邻接点。 ...
无向图的邻接表表示法
qq_41025769的博客
04-19 3131
总结： 1、邻接表表示由表头结点、邻接结点组成； 2、为了方便插入边（即将两个结点连起来）的操作，定义边（两个邻接点下标+边权重）； 3、表头结点的权重存放的是结点的权重，邻接点的权重存放的是边权重！ //无向图的邻接表表示法 #include <stdio.h> #include <stdlib.h> #define MaxVertexNum 100 typedef int Vertex; typedef int WeightType; typedef char DataType.
数据结构之无向图邻接表DFS之查询遍历关节点
EditGP的专栏
10-21 1181
#include using namespace std; #define MAXVEX 100 typedef char VType; typedef struct ArcNode { int adjvex; ArcNode *pNextArc; }ArcNode; typedef struct VexNode { VType data; ArcNode *pFirstArc; }Ve
用一维数组g[]存储有4个顶点的无向图如下:_图论开坑图存储的三种方式
weixin_39688875的博客
11-28 1667
图是一种常见的抽象模型，在计算机专业中的应用尤其广泛。数据结构和算法是计算机专业的必修课程，而图则是数据结构和算法课上的必修内容，图论问题是算法竞赛的常客，图的重要性可见一斑。其它算法学的再好，不会图论的话，那永远也称不上是算法高手。那么问题就来了，怎么学习图算法呢。要学习图算法，首先咱得有个图不是，所以学习图算法的第一关就这么来了–怎样能创建/存储图呢？一.基本概念再讲具体的存储之前，...
2023-04-08 无向有权图之最短路径问题
lsgwr的博客
04-08 1736
初始化distances[start]=0，其余distance值为+∞对所有的边进行第1次松弛操作,则求出了到所有点经过的边数最多为1的最短路对所有的边进行第2次松弛操作,则求出了到所有点经过的边数最多为2的最短路对所有的边进行第3次松弛操作,则求出了到所有点经过的边数最多为3的最短路对所有的边进行第v-1次松弛操作,则求出了到所有点经过的边数最多为v-1的最短路如果对所有边再进行一次松弛操作，还能更新最小路径的值数组distances，则说明图中包含负权环。
2023-04-07 无向有权图之最小生成树问题
lsgwr的博客
04-07 2305
用n-1条边把含有n个顶点的图连接起来就形成了图的生成树,一个图一般都有很多个不同的生成树在有权图中，不同的n-1条边形成的不同生成树其权总和一般也就不同，权值总和最小的就叫最小生成树带权图最小生成树问题切分定理Kruskal求最小生成树Prim求最小生成树。
01图论基础
Edward_Legend的博客
11-17 1540
什么是图 图的基本示意图 图是描述复杂事务的数据表示形式，由节点和边组成，数学上一般表述为 图G-（V，E）。其中的V（vertical）代表节点，可被理解为事物。 而E（edge）代表边，描述的是两个事物之间的关系。例如一个图的社交网络图，每个人都可视为节点，而人与人之间的关系可被视为边。 而在我们的推荐系统中，用户与物品之间的交互关系，用户与用户自身的关系，物品与物品之间的关系，完全可由一张图完整的进行描述。如下图所示： 用户与物品之间的关系图 无向图与有向图 无向图 有向图 双向图 无向图是由没有方
图的存储结构：邻接矩阵与深度优先遍历
本文将深入探讨如何使用邻接矩阵来存储图，并实现深度优先遍历（DFS）和广度优先遍历（BFS）。邻接矩阵是一种常见的图数据结构，尤其适用于表示图中顶点之间的连接关系，无论是有向图还是无向图。在邻接矩阵中，每个...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值