【数据结构】第六章——图（详解）

最新推荐文章于 2022-04-21 23:18:21 发布
最新推荐文章于 2022-04-21 23:18:21 发布
阅读量732 收藏 11
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45888298/article/details/112485582
版权

前言：
本系列是笔者暑假自学数据结构的笔记整理而来，共126页，3w+字。现在正式开学上课，补充老师所讲内容，并且仔细勘误，根据老师的教学进度分章节发布在CSDN上。
教材使用的是王红梅等所著的数据结构——从概念到C++实现（第三版）。
暑假自学时期主要参考的网课：
青岛大学-王卓
武汉大学-李春葆

隔了好久，补发。

目录

定义与概念

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

图的存储结构

在这里插入图片描述
在这里插入图片描述

/*
    图的基本运算
    InitGraph(&g):图初始化
    ClearGraph(&g):销毁图
    DFS(G, V):从顶点v出发深度优先遍历
    BFS(G, v):从顶点v出发广度优先遍历
*/

#define MAXV 100//最大顶点个数
#define InfoType int
typedef struct
{
    int no;//顶点编号
    InfoType info;//顶点其他信息
}VertexType;

typedef struct //图的定义
{
    int edge[MAXV][MAXV];//邻接矩阵
    int n, e;//顶点数边数
    VertexType vexs[MAXV];//存放顶点信息
}MGraph;

在这里插入图片描述
在这里插入图片描述

//图的邻接表存储类型定义如下：
typedef struct ANode
{
    int adjvect;//该边的终点编号
    struct ANode *nextare;//指向下一条边的指针
    InfoType info;//该边的权值等信息
}ArcNode;

typedef struct Vnode
{
    VertexType data;//顶点信息
    ArcNode *firstarc;//指向第一条便
}VNode;

typedef struct 
{
    VNode adjlist[MAXV];//邻接表
    int n, e;//图中顶点数n和边数e
}ALGraph;

在这里插入图片描述
在这里插入图片描述

图的遍历

在这里插入图片描述

//DFS,时间复杂度O(n+e)
void DFS(ALGraph *G, int v)
{
    ArcNode *p;
    int w;
    int visited[MAXV];
    visited[v] = 1;//用visited数组表示节点是否被访问过
    cout << v;//输出被访问顶点的编号
    p = G->adjlist[v].firstarc;//p指向顶点v的第一条边的边头节点
    while (p != nullptr)
    {
        w = p->adjvect;
        if (visited[w] == 0)
        {
            DFS(G, w);//若w顶点未访问，递归访问它
        }
        p = p->nextare;//p指向顶点v的下一条边的边头节点
    }
}

在这里插入图片描述
在这里插入图片描述

//BFS,时间复杂度为O(n+e)
void BFS(ALGraph *G, int v)
{
    ArcNode *p;
    int w, i;
    int queue[MAXV], front = 0, rear = 0;//定义循环队列
    int visited[MAXV];
    for (int i = 0; i < G->n; i++)
    {
        visited[i] = 0;//访问标志数组初始化
    }
    cout << v;//输出被访问顶点的编号
    visited[v] = 1;//置已被访问顶点的编号
    rear = (rear + 1)%MAXV;
    queue[rear] = v;//v进队
    while (front != rear)//队列不空
    {
        front = (front + 1)%MAXV;
        w = queue[front];//出队并赋给w
        p = G->adjlist[w].firstarc;//找w的第一个邻接点
        while (p != nullptr)
        {
            if (visited[p->adjvect] == 0)
            {
                cout << p->adjvect;//访问之
                visited[p->adjvect] = 1;
                rear = (rear + 1)%MAXV;//相邻顶点进队
                queue[rear] = p->adjvect;
            }
            p = p->nextare;//找下一个邻接顶点
        }
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

void DFS1(ALGraph *G)
{
    int i;
    for (int i = 0; i < G->n; i++)
    {
        if (visited[i] == 0)
        {
            DFS(G, i);
        }
    }
}

在这里插入图片描述

void BFS1(ALGraph *G)
{
    int i;
    for (int i = 0; i < G->n; i++)
    {
        if (visited[i] == 0)
        {
            BFS(G, i)
        }
    }
}

在这里插入图片描述

int visited[MAXV];
bool Connect(ALGraph *G)//判断无向图G的连通性
{
    int i;
    bool flag = true;
    for (int i = 0; i < G->n; i++)
    {
        visited[i] = 0;//visited[]数组置初值
    }
    DFS(G, 0);//从顶点0开始深度优先遍历
    for (int i = 0; i < G->n; i++)
    {
        if (visited[i] == 0)
        {
            flag = false;
            break;
        }
    }
    return flag;
}

在这里插入图片描述

void ExistPath(ALGraph *G, int u, int v, bool &has)
{
    //has表示u到v是否有路径
    int w;
    ArcNode *p;
    visited[u] = 1;//置已访问标记
    if (u == v)//找到一条路径
    {
        has = true;//置has为true并结束算法
        return;
    }
    p = G->adjlist[u].firstarc;//p指向顶点u的第一个相邻点
    while (p != nullptr)
    {
        w = p->adjvect;//w为顶点u的相邻顶点
        if (visited[w] == 0)//若w顶点未访问，递归访问它
        {
            ExistPath(G, w, v, has);
        }
        p = p->nextare;//p指向顶点u的下一个相邻点
    }
}

在这里插入图片描述

void FindaPath(ALGraph *G, int u, int v, int path[], int d)
{
    //d表示path中的路径长度，初值为-1
    int w, i;
    ArcNode *p;
    visited[u] = 1;
    d++;//路径长度d增1，顶点u加入到路径中
    path[d] = u;
    if (u == v)//找到一条路径后输出并返回
    {
        cout << "一条简单路径为：";
        for (int i = 0; i <= d; i++)
        {
            cout << path[i];
        }
        cout << '\n';
        return;//找到一条路径后返回
    }
    p = G->adjlist[u].firstarc;//p指向顶点u的第一个相邻点
    while (p != nullptr)
    {
        w = p->adjvect;//相邻点的编号为w
        if (visited[w] == 0)
        {
            FindaPath(G, w, v, path, d);
        }
        p = p->nextare;//p指向顶点u的下一个相邻点
    }
}

在这里插入图片描述

void PathAll(ALGraph *G, int u, int v, int l, int path[], int d)
{
    //d是到当前为止已走过的路径长度，调用时初值为-1
    int w, i;
    ArcNode *p;
    visited[u] = 1;//路径长度增1
    d++;
    path[d] = u;//将当前顶点添加到路径中
    if (u == v && d==l)//输出一条路径
    {
        for (int i = 0; i <= d; i++)
        {
            cout << path[i] << '\n';
        }
    }
    p = G->adjlist[u].firstarc;//p指向u的第一条边的边头节点
    while (p != nullptr)
    {
        w = p->adjvect;//w为u的邻接顶点
        if (visited[w] == 0)//若顶点未标记访问，则递归访问之
        {
            PathAll(G, w, v, l, path, d)
        }
        p = p->nextare;//找u的下一个邻接顶点
    }
    visited[u] = 0; //恢复环境，使该顶点可重新使用
}

在这里插入图片描述

typedef struct 
{
    int data;//顶点编号
    int parent;//前一个顶点的位置
}Quere;

void ShortPath(ALGraph *G, int u, int v)
{
    //输出从顶点u到顶点v的最短逆路径
    ArcNode *p;
    int w, i;
    Quere qu[MAXV];//定义非循环队列
    int front = -1, rear = -1;//队列的头、尾指针
    int visited[MAXV];
    for (int i = 0; i < G->n; i++)//访问标记置初值0
    {
        visited[i] = 0;
    }
    rear++;//顶点u进队
    qu[rear].data = u;
    qu[rear].parent = -1;
    visited[u] = 1;
    while (front != rear)//队不空时循环
    {
        front++;//出队顶点w
        w = qu[front].data;
        if (w == v)//输出逆路径
        {
            i = front;
            while (qu[i].parent != -1)
            {
                cout << qu[i].data;
                i = qu[i].parent;
            }
            cout << qu[i].data;
            break;
        }
        p = G->adjlist[w].firstarc;//找w的第一个邻接点
        while (p != nullptr)
        {
            if (visited[p->adjvect] == 0)
            {
                visited[p->adjvect] = 1;
                rear++;//将w的未访问过的邻接点进队
                qu[rear].data = p->adjvect;
                qu[rear].parent = front;
            }
            p = p->nextare;//找w的下一个邻接点
        }
    }
}

生成树

在这里插入图片描述

最小生成树

在这里插入图片描述
在这里插入图片描述

#define INF 32767
void Prim(MGraph g, int v)
{
    int lowcost[MAXV];
    int min;
    int closet[MAXV], i, j, k;
    for (int i = 0; i < g.n; i++)
    {
        lowcost[i] = g.edge[v][i];
        closet[i] = v;
    }
    for (int i = 1; i < g.n; i++)
    {
        min = INF;
        for (int j = 0; j < g.n; j++)
        {
            if (lowcast[j] != 0 && lowcost[j] < min)
            {
                min = lowcost[j];
                k = j;
            }
        }
        cout << closet[k] << k << min;
        lowcast[k] = 0;
        for (int j = 0; j < g.n; j++)
        {
            if (lowcast[j] != 0 && g.edges[k][j] < lowcast[j])
            {
                lowcost[j] = g.edge[k][j];
                closet[j] = k;
            }
        }
    }
}

在这里插入图片描述
在这里插入图片描述

typedef struct 
{
    int u;//边的起始顶点
    int v;//边的终止顶点
    int w;//边的权值
}Edge;

void Kruskal(MGraph g)
{
    int i, j, u1, v1, sn1, sn2, k;
    int vset[MAXV];
    Edge E[MAXV];//存放所在边
    k = 0;//E数组的下标从0开始计
    for (int i = 0; i < g.n; i++)//由g产生的边集E
    {
        for (int j = 0; j < g.n; j++)
        {
            if (g.edge[i][j] != 0 && g.edge[i][j] != INF)
            {
                E[k].u = i;
                E[k].v = j;
                E[k].w = g.edge[i][j];
                k++;
            }
            
        }
    }
    InsertSort(E, g, e);//用直接插入排序对E数组按权值递增排序
    for (int i = 0; i < g.n; i++)//初始化辅助数组
    {
        vset[i] = i;
        k = 1;//k表示当前构造生成树的第几条边
        j = 0;//E中边的下标，初值为0
        while (k < g.n)//生成的边数小于n时循环
        {
            u1 = E[j].u;//取一条边的头尾顶点
            v1 = E[j].v;
            sn1 = vset[u1];
            sn2 = vset[v1];//分别得到两个顶点所属的集合编号
            if (sn1 != sn2)//两顶点属于不同的集合
            {
                cout << u1 << v1 << E[j].w;
                k++;//生成边数增1
                for (int i = 0; i < g.n; i++)//两个集合统一编号
                {
                    if (vset[i] == sn2)//集合编号为sn2的改为sn1
                    {
                        vset[i] = sn1;
                    }
                }
            }
            j++;//扫描下一条边
        }
    }
}

在这里插入图片描述

最短路径

在这里插入图片描述

void Dijkstra(MGraph g, int v)
{
    int dist[MAXV], path[MAXV];
    int s[MAXV];
    int mindis, i, j, u;
    for (int i = 0; i < g.n; i++)
    {
        dist[i] = g.edge[v][i];//距离初始化
        s[i] = 0;//s[]置空
        if (g.edge[v][i] < INF)//路径初始化
        {
            path[i] = v;//顶点v到i有边时
        }
        else
        {
            path[i] = -1;//顶点v到i没边时
        }
    }
    s[v] = 1;//源点v放入s中
    for (int i = 0; i < g.n; i++)//循环n-1次
    {
        mindis = INF;
        for (int j = 0; j < g.n; j++)
        {
            if (s[j] == 0 && dist[j] < mindis)
            {
                u = j;
                mindis = dist[j];
            }
        }
        s[u] = 1;//顶点u放入s中
        for (int j = 0; j < g.n; j++)//修改不在s中的顶点的距离
        {
            if (s[j] == 0)
            {
                if (g.edge[u][j] < INF && dist[u] + g.edge[u][j] < dist[j])
                {
                    dist[j] = dist[u] + g.edge[u][j];
                    path[j] = u;
                }
            }
        }
    }
    Dispath(dist, path, s, g.n, v);//输出最短路径
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

void Floyd(MGraph g)//求每对顶点之间的最短路径
{
    int A[MAXV][MAXV];//建立数组A
    int path[MAXV][MAXV];//建立path数组
    int i, j, k;
    for (int i = 0; i < g.n; i++)
    {
        for (int j = 0; j < g.n; j++)
        {
            A[i][j] = g.edge[i][j];
            if (i != j && g.edge[i][j] < INF)
            {
                path[i][j] = i;//i和j顶点之间有一条边时
            }
            else
            {
                path[i][j] = -1;//i和j顶点之间没有一条边时
            }
            
        }
        
    }
    for(k = 0; k < g.n; k++)//求Ak[i][j]
    {
        for(i = 0; i < g.n; i++)
        {
            for(j = 0; j < g.n; j++)
            {
                if (A[i][j] > A[i][k] + A[i][j])//找到更短路径
                {
                    A[i][j] = A[i][k] + A[i][j];//修改路径长度
                    path[i][j] = path[k][j];//修改最短路径为经过顶点k
                }
            }
        }
    }
}

在这里插入图片描述

typedef struct//表头节点类型
{
    VertexType data;//顶点信息
    int count;//存放顶点入度
    ArcNode *firstarc;//指向第一条边
}VNode;
void TopSort(Vnode adj[], int n)
{
    int i, j;
    int St[MAXV], top = -1;//栈的指针为top
    ArcNode *p;
    for (int i = 0; i < n; i++)
    {
        if (adj[i].count == 0)//入度为0的顶点进栈
        {
            top++;
            St[top] = i;
        }
    }
    while (top > -1)//栈不空时循环
    {
        i = St[top];//出栈
        top--;
        cout << i;
        p = adj[i].firstarc;
        while (p != nullptr)
        {
            j = p->adjvect;
            adj[j].count--;
            if (adj[j].count == 0)
            {
                top++;
                St[top] = j;
            }
            p = p->nextare;//找下一个相邻顶点
        }
    }
}

AOE网和关键路径

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
以上 如果此篇博客对您有帮助欢迎点赞与转发 有疑问请留言或私信 2021/1/12

满脸写着暴躁
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
无向简单图怎么判断_无向图的基本算法
weixin_39685459的博客
12-23 4097
根据性质，图可以分为无向图和有向图。本文先介绍无向图，后文再介绍有向图。之所以要研究图，是因为图在生活中应用比较广泛。无向图图是若干个顶点(Vertices)和边(Edges)相互连接组成的。边仅由两个顶点连接，并且没有方向的图称为无向图。在研究图之前，有一些定义需要明确，下图中表示了图的一些基本属性的含义，这里就不多说明。图的API表示在研究图之前，我们需要选用适当的数据结构来表示图，有时候，我...
数据结构与算法详解——链表篇（附c++实现代码）
JMasker的博客
05-01 3180
链表详解及完整实现
非线性数据结构——图
qq_44145934的博客
07-30 2008
非线性数据结构图 认识图 表示图 图的遍历 图的定义： 图中的数据元素通常称为顶点，所有顶点构成顶点集，我们通常用V(Vetex)来表示。 元素间的关系用边来表示，通常用E(edge)来表示边集合。 G1 = { V, E }，V = { v1, v2, v3, v4, v5}，E = { (v1, v2) , (v1, v4), (v2, v3), (v2, v5), (v3, v4...
python中判断无向图是否有环_开启图结构：图的创建和遍历
weixin_39928233的博客
11-21 167
文章和资源同步于微信公众号：算法工程师之路希望各位在关注专栏的同时关注下公众号呗~~拜托了！今天我们来聊一聊图结构，虽然在面试中图结构用的不多，但是我真的觉得图结构可以综合很多知识点，以及STL中容器的使用，并且需要很强大的逻辑性！是一个锻炼脑子的东西，并且Coding起来非常之爽~~开启图结构的学习：图的创建和遍历​mp.weixin.qq.com图的建立我们使用算法来模拟图结构之前，需要首先搞...
简单无向图计数
最后一次修改
04-21 1126
图的同构计数
判断随机产生的任意简单无向图的连通性
12-17
由函数随机产生一简单无向图的邻接矩阵，并输出是否连通
数据结构与算法——二叉树详解java
qq_40688338的博客
12-23 961
我们有序数组查找快，可以通过二分查找快速的查找到数据，但是要在有序数组中插入一个数的话，就必须先找到插入数据项的位置，然后将所有插入位置后面的数据项后移以为，给新的数据腾出空间，同时删除数据也是一样的道理，可以知道这样的话是很浪费时间的， 同时另外的一种数据结构——链表，链表的插入和删除很快，我们只需要改变一些引用，但是查找数据就会很慢，因为我们无论查找到什么数据，都需要从链表的第一个数据开始，遍...
[详细完整版]数据结构六.pdf
07-11
在这个编程示例中，我们看到了如何在C语言中使用数据结构来存储和操作学生信息。主要涉及以下几个核心知识点： 1. **结构体（Struct）**：`struct student`定义了一个结构体类型，它包含学号（Sno）、姓名（Name）...
【数据结构】——快排详解
qq_43412060的博客
02-18 3314
上一篇文章我们介绍了八大排序中的七种，今天这篇文章主要来详细介绍一种比较重要也是常用的一种排序算法——快速排序~ 一、什么是快排？ 快速排序是一种二叉树结构的交换排序方法。相当于是冒泡排序的一种升级，都是属于交换排序类，通过不断比较和移动交换来实现排序。 其基本思想是：任意取待排序元素序列中的某个元素作为基准值，按照这个排序码把待排序集合分割成两个子序列，左子序列中所有元素都小于该基准值，右子序列...
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
### 数据结构C++ 线性表——顺序表和单链表基本操作 #### 一、概述 在《数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx》文档中，作者详细介绍了如何在C++中实现顺序表和单链表的基本操作，并...
无向简单图.zip
07-06
博客数据结构无向简单图对应的项目文件（代码和界面），基于Qt实现，原版封装。
简单无向图(c++版)
RGBMarco的博客
08-15 6689
Graph.h#pragma once #include <string> #include <sstream> #include <fstream> #include <iterator> #include <stack> #include <queue>class Graph { private: class EdgeList { public: clas
【图论】已知度数列情况下的简单无向图的判断方法
JeronZhou的博客
03-06 3万+
在已知度序列的情况下，如何判断它是否为简单无向图呢？ 第一步·判断是否为无向图 利用握手定理及其推论： 1.无向图的顶点度数之和等于边数的两倍。 2.对于无向图，有奇数个度的顶点必为偶数个。 凡是不满足的，就不是无向图。 第二步·判断是否为简单图 这里需要用到Havel定理。 由于此定理的文字表述过于复杂，故在此只给出方法。 1.对已知的度序列进行降序排列（相等的放在一起）。 2.假设最大的...
数据结构——图的五种种类【无向图-有向图-简单图-完全无向图-有向完全图】
热门推荐
刘鑫磊
02-11 9万+
目录： 一：无向图 1.定义 2.图形化解释 3.结合​表达式介绍 二：有向图 1.定义 2.图形化解释 3.结合​表达式介绍 有向图和无向图区别： 三：简单图 1.定义 2.图形化解释 四：完全无向图 1.定义 2.图形化解释 五：有向完全图 1.定义 2.图形化解释 一：无向图 1.定义 若顶点到之间的边没有方向，则称这条边为无向边（Edge...
【NOIP2017提高A组模拟9.7】简单无向图
时光真疯狂, 我一路执迷于匆忙.
09-08 667
Description给出一张n个点的简单图，和每个点的度数di，求这样的图的个数。 n<=2000,di=1,2Solution既然度数只有1,2两种，那么显然这种图中只有环和链。 但是这个环有要求大小>=3，因为简单图不能有重边。 很好想到把环和链分开考虑，链的个数是确定的。 那么我们设si,j表示i个2，放到j个环中的方案数， 如果没有考虑环的大小限制s显然是斯特林数， 但是有限制
无向图，连通图
bishen8589的博客
03-04 2万+
https://blog.csdn.net/kongduxue/article/details/81432270 https://blog.csdn.net/qq_33913037/article/details/71213985 **一、 图（Graph）**是由顶点(vertex)的有穷非空集合和顶点之间边(edge)的集合组成，通常表示为：G(V,E)，其中，G表示一个图，V是图G中顶点的...
JZOJ5351. 【NOIP2017提高A组模拟9.7】简单无向图 DP+组合数学
老臣
09-08 612
题意：给出n个点和每个点的度数，问能有多少种组合方式形成一个简单无向图（多个联通块允许）。n<=2e3.这题充分暴露出我的组合数学有多差。。 首先你需要手玩一段时间发现构造的图要不然是链要不然是环。 然后我们就可以按照情况DP了。 首先对于所有di=1的点，我肯定只能连成一条链。 那很好办了，设f[i][j]f[i][j]表示有i个度数为2的点，j个用来构造环，i-j个用来构造链的情况。
无向简单图怎么判断_在无向图中,基本路一定是简单路.
weixin_30224993的博客
01-16 1079
【填空题】设集合 则集合 上的整除关系是偏序关系,请写出这个偏序关系____.【填空题】重要等值式中德摩根律为 ____.【单选题】设集合 上的关系 具有( ).【其它】吉祥物 三组不同形式的辅助图形【单选题】设集合 则下列命题正确的是 ( ).【填空题】重要等值式中的结合律为 ____.【填空题】设有限集 的元素个数为 , 则 的子集个数为____.【其它】请上传你们的实验报告。以“学号+姓名”...
Tarjan 算法思想求强连通分量及求割点模板（超详细图解）
harry12138小白的博客
11-09 821
割点定义 在一个无向图中，如果有一个顶点，删除这个顶点及其相关联的边后，图的连通分量增多，就称该点是割点，该点构成的集合就是割点集合。 若在图G中（如下图），删除uv这条边后，图的连通分量增多，则u和v点称为割点，uv这条边称为桥或割边。 显然，有割点的图不是哈密尔顿图。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值