数据结构学习——图

最新推荐文章于 2022-04-26 00:30:19 发布
最新推荐文章于 2022-04-26 00:30:19 发布
阅读量193 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mingbo64/article/details/117479789
版权

图型(Graph)结构：

什么是图型结构：由有穷且非空的顶点和顶点之间的边组成的集合
通常表示：G(V,E) G表示一个图，V是图中顶点(元素)的集合，E是图中边(元素与元素之间的关系)集合

无向图：

    边用(A,B)方式表示，点与点之间是互通
    在无向图中，任意两个顶点之间都有边，则该无向图称为完全无向图
    在有n个顶点的完全无向图中，有  n*(n-1)/2  条边

有向图：

    边用<A,B>方式表示，仅表示从A点到B点的边，有向图中的边也称为弧，A是弧尾，B是弧头
    在有向图中，任意两个顶点之间存在方向相反的两条弧，则该有向图成为完全有向图
    在有n个顶点的完全有向图中，有  n*(n-1)  条边

注意：不存在顶点到自身的边，并且两个顶点之间不存在重复的边，这种图叫做简单图，数据结构中只研究简单图

稀疏图：图中点多边少的图
稠密图：图中边多点少的图
图中的点与点之间的边带数据，这些数据称为权重，该图称为带权图，也称为网 

依附于某顶点的边的数量称为该顶点的度，如果是有向图，分为出度(从顶点出发的弧的数量)、
入度(到该顶点弧的数量)

在这里插入图片描述

路径：顶点到顶点之间经过的边称为路径，边的数量称为路径的长度
顶点序列中不重复出现的路径称为简单路径

如果顶点V1到顶点V2之间有路径，则V1和V2是连通的，如果图中的任意顶点之间都是连通的，则称为连通图，如果一个图中有n个顶点，那么至少需要n-1条边才能达到连通图

图的存储结构：

邻接矩阵：

    用一个一维数组V来存储n个顶点，用一个n*n的二维数组E来存储边
    无向图中沿斜对角线对称
    char V[n] = {A,B,C,D,E,F,G};
        A  B  C  D  E  F  G
    A  [0][1][1][0][0][0][0]
    B  [0][0][0][1][0][0][0]
    C  [0][0][0][1][0][1][0]
    D  [0][0][0][0][1][0][0]
    E  [0][0][0][0][0][0][1]
    F  [0][0][0][0][0][0][0]
    G  [0][0][0][0][0][1][0]
    
    在二维数组中E[i][j]的值为1，则表示顶点V[i]，到顶点V[j]之间有边
    注意：由于不存在自己到自己的边，左对角线上的值为假

    邻接矩阵的优点：可以方便计算出顶点的出入度数
            缺点： 当图是稀疏图时，会非常地浪费存储内存

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

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

typedef struct Graph
{
	char* v;	//顶点的一维数组
	char* e;	//边的二维数组，用一维数组操作
	int cnt;	//顶点的数量
}Graph;

Graph* create_graph(const char* str)
{
	//	申请图结构所需要的内存
	Graph* graph = malloc(sizeof(Graph));
	//	计算顶点的数量
	graph->cnt = strlen(str);//sizeof 会多一个‘/0’
	//	申请存储顶点所需要的内存
	graph->v = malloc(graph->cnt);
	//	存储顶点
	strcpy(graph->v,str);//拷贝
	//	申请存储边所需要的内存
	graph->e = calloc(graph->cnt,graph->cnt);//cnt行cnt列清零
	
	return graph;
}

//	添加边
bool add_edge_graph(Graph* graph,char v1,char v2)
{
	int x = -1, y = -1;
	for(int i=0; i<graph->cnt; i++)
	{
		if(graph->v[i] == v1)
			x = i;
		if(graph->v[i] == v2)
			y = i;
	}
	if(-1 == x || -1 == y) return false;
	
	//	有向图中
	graph->e[x*graph->cnt+y] = 1;
	//	如果是无向图，加上该行
	//graph->e[y*graph->cnt+x] = 1;
	return true;
}

//	计算顶点的入度
int in_degree_graph(Graph* graph,char v)
{
	for(int y=0; y<graph->cnt; y++)
	{
		if(v == graph->v[y])
		{
			int id = 0;
			for(int x=0; x<graph->cnt; x++)
			{
				id += graph->e[x*graph->cnt+y];
			}
			return id;
		}
	}
	return -1;
}

//	计算顶点的出度
int out_degree_graph(Graph* graph,char v)
{
	for(int x=0; x<graph->cnt; x++)
	{
		if(v == graph->v[x])
		{
			int od = 0;
			for(int y=0; y<graph->cnt; y++)
			{
				od += graph->e[x*graph->cnt+y];	
			}
			return od;
		}
	}
	return -1;
}



void _DFS(Graph* graph,char* vflag,int i)
{
	if(vflag[i]) return;
	printf("%c ",graph->v[i]);
	vflag[i] = 1;

	for(int y=0; y<graph->cnt; y++)
	{
		if(graph->e[i*graph->cnt+y])	
			_DFS(graph,vflag,y);
	}
}

//	深度优先遍历
void DFS_show(Graph* graph)
{
	//	遍历过的顶点加标志位
	//	变长数组不能初始化
	char vflag[graph->cnt]; 
	//	内存赋值为0
	memset(vflag,0,graph->cnt);

	for(int i=0; i<graph->cnt; i++)
	{
		//	每个顶点进行深度遍历
		_DFS(graph,vflag,i);	
	}
}

//	广度优先遍历
void BFS_show(Graph* graph)
{
	char vflag[graph->cnt];
	memset(vflag,0,graph->cnt);

	ListQueue* queue = create_list_queue();
	for(int i=0; i<graph->cnt; i++)
	{
		if(!vflag[i])
		{
			push_list_queue(queue,i);
			vflag[i] = 1;
		}
		while(!empty_list_queue(queue))
		{
			int j = head_list_queue(queue);
			printf("%c",graph->v[j]);

			pop_list_queue(queue);
			for(int y=0; y<graph->cnt; y++)
			{
				if(graph->e[j*graph->cnt+y] && !vflag[y])
				{
					push_list_queue(queue,y);
					vflag[y] = 1;
				}
			}
		}
	}
}


void show_graph(Graph* graph)
{
	printf("  ");
	for(int i=0; i<graph->cnt; i++)
	{
		printf("%c ",graph->v[i]);	
	}
	printf("\n");

	for(int i=0; i<graph->cnt; i++)
	{
		printf("%c ",graph->v[i]);
		for(int j=0; j<graph->cnt; j++)
		{
			printf("%hhd ",graph->e[i*graph->cnt+j]);//*是因为一位数组是一行数据表
 		}
		printf("\n");
	}
}

int main(int argc,const char* argv[])
{
	char* str = "ABCDEFG";
	Graph* graph = create_graph(str);
	add_edge_graph(graph,'A','B');
	add_edge_graph(graph,'A','C');
	add_edge_graph(graph,'B','D');
	add_edge_graph(graph,'C','D');
	add_edge_graph(graph,'C','F');
	add_edge_graph(graph,'D','E');
	add_edge_graph(graph,'D','F');
	add_edge_graph(graph,'E','G');
	add_edge_graph(graph,'G','F');
	show_graph(graph);

	printf("in:%d\n",in_degree_graph(graph,'C'));
	printf("out:%d\n",out_degree_graph(graph,'C'));
	DFS_show(graph);
}

邻接表：

    边：
        指向顶点的下标
        下一条边的地址
    顶点：
        数据
        第一条边的地址
    图：
        由顶点组成的数组
        顶点数量
    优点：计算出度很方便，可以大大地节约空间
    缺点：计算入度麻烦

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include "list_queue.h"

//	边
typedef struct Edge
{
	int index;			//	顶点下标
	struct Edge* next;	//	下一条边
}Edge;

//	创建到index顶点的边
Edge* create_edge(int index)
{
	Edge* edge = malloc(sizeof(Edge));
	edge->index = index;
	edge->next = NULL;
	return edge;
}

//	顶点
typedef struct Vertex
{
	char vertex;	//	顶点数据
	Edge* first;	//	指向第一条边
}Vertex;

//	图
typedef struct Graph
{
	Vertex* v;	//	顶点表
	int cnt;	//	顶点的数量
}Graph;

//	创建图
Graph* create_graph(const char* str)
{
	//	申请图所需要的内存
	Graph* graph = malloc(sizeof(Graph));	
	//	计算顶点的数量
	graph->cnt = strlen(str);
	//	申请存储顶点所需要的内存
	graph->v = malloc(sizeof(Vertex)*graph->cnt);
	//	初始化顶点表
	for(int i=0; i<graph->cnt; i++)
	{
		graph->v[i].vertex = str[i];	
		graph->v[i].first = NULL;
	}
	return graph;
}

//	添加边
bool add_edge_graph(Graph* graph,char v,char v1)
{
	for(int i=0; i<graph->cnt; i++)
	{
		if(v == graph->v[i].vertex)
		{
			for(int j=0; j<graph->cnt; j++)
			{
				if(v1 == graph->v[j].vertex)	
				{
					//	类似链表头添加
					Edge* edge = create_edge(j);
					edge->next = graph->v[i].first;
					graph->v[i].first = edge;
					return true;
				}
			}
		}
	}
	return false;
}

//	计算出度
int out_degree_graph(Graph* graph,char v)
{
	int od = 0;
	for(int i=0; i<graph->cnt; i++)
	{
		if(v == graph->v[i].vertex)
		{
			for(Edge* e=graph->v[i].first; e; e=e->next)
			{
				od++;		
			}
			return od;
		}
	}
	return -1;
}


//	计算入度
int in_degree_graph(Graph* graph,char v)
{
	//	找到v的下标
	for(int i=0; i<graph->cnt; i++)
	{
		if(v == graph->v[i].vertex)
		{
			int id = 0;
			for(int j=0; j<graph->cnt; j++)
			{
				for(Edge* e=graph->v[j].first; e; e=e->next)
				{
					i == e->index && id++;
				}
			}
			return id;
		}
	}
	return -1;
}

void _DFS_show_graph(Graph* graph,bool* vflag,int i)
{
	if(vflag[i]) return;
	printf("%c",graph->v[i].vertex);
	vflag[i] = 1;

	for(Edge* e=graph->v[i].first; e; e=e->next)
	{
		_DFS_show_graph(graph,vflag,e->index);	
	}
}

//	深度优先遍历
void DFS_show_graph(Graph* graph)
{
	bool vflag[graph->cnt];
	memset(vflag,0,graph->cnt);

	for(int i=0; i<graph->cnt; i++)
	{
		_DFS_show_graph(graph,vflag,i);	
	}
}


//	广度优先遍历
void BFS_show_graph(Graph* graph)
{
	bool vflag[graph->cnt];
	memset(vflag,0,graph->cnt);
	ListQueue* queue = create_list_queue();

	for(int i=0; i<graph->cnt; i++)
	{
		if(!vflag[i])//取反为真，没被标记
		{
			push_list_queue(queue,i);
			vflag[i] = 1;
		}
		while(!empty_list_queue(queue))
		{
			int j = head_list_queue(queue);
			printf("%c",graph->v[j].vertex);
			pop_list_queue(queue);

			for(Edge* e=graph->v[j].first; e; e=e->next)
			{
				if(!vflag[e->index])
				{
					push_list_queue(queue,e->index);
					vflag[e->index] = 1;
				}
			}
		}
	}
}

void show_graph(Graph* graph)
{
	for(int i=0; i<graph->cnt; i++)
	{
		printf("index:%d v:%c ",i,graph->v[i].vertex);
		for(Edge* e=graph->v[i].first; e; e=e->next)
		{
			printf("->e:%d ",e->index);	
		}
		printf("\n");
	}
}

int main(int argc,const char* argv[])
{
	char* str = "ABCDEFG";
	Graph* graph = create_graph(str);
	add_edge_graph(graph,'A','B');
	add_edge_graph(graph,'A','C');
	add_edge_graph(graph,'B','D');
	add_edge_graph(graph,'C','D');
	add_edge_graph(graph,'C','F');
	add_edge_graph(graph,'D','E');
	add_edge_graph(graph,'D','F');
	add_edge_graph(graph,'E','G');
	add_edge_graph(graph,'G','F');
	show_graph(graph);
	for(int i=0; i<strlen(str); i++)
	{
		printf("%c id: %d\n",str[i],in_degree_graph(graph,str[i]));	
	}
//	DFS_show_graph(graph);
	BFS_show_graph(graph);
}

在这里插入图片描述

十字链表：

    边：
        弧尾下标
        弧头下标
        指向相同弧尾的下一条边
        指向相同弧头的下一条边
    顶点：
        数据
        指向第一条出度的边
        指向第一条入度的边
    图：
        由顶点组成的数组
        顶点数量

邻接多重表：

    是一种专门存储无向图的一种结构
    边：
        i、j两个互相依附于该边的顶点下标
        inext 指向下一条依附于i顶点的边
        jnext 指向下一条依附于j顶点的边
    顶点：
        数据
        指向与顶点有关系的一条边
    图：
        由顶点组成的数组
        顶点数量
明泊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构图型（Graph）结构
FangOmg的博客
09-04 1161
前言 C语言表的理解及介绍 一、功能受限的表： 栈：只有一个进出的出入口的表结构，先进后出，FILO 顺序栈： 数据项： 存储元素的内存首地址 栈的容量 栈顶的位置 运算： 创建、销毁、入栈、出栈、栈满、栈空、栈顶 注意： 栈顶指向顶部的第一个数据，称为满增栈 栈顶指向接下去要入栈的位置，成为
图
weixin_45834525的博客
05-10 114
图 图型结构（Graph）: 什么是图型结构：由有穷且非空的顶点和顶点之间的边组成的集合 通常表示：G（V,E）G表示一个图，V是图中顶点(元素)的集合，E是图中边(元素与元素之间的关系)集合 无向图： 边用(A,B)方式表示，点与点之间是互通 在无向图中，任意两个顶点之间都有边，则该无向图称为完全无向图 在有n个顶点的完全无向图中，有 n*(n-1)/2 边 有向图： 边用<A,B>方式表示，仅表示从A点到B点的边，有向图中的边也称为弧，A是弧尾，B是弧头 在有向图中，任意两个顶点之间存在
图型(Graph)结构
Everglow21的博客
06-18 935
图型(Graph)结构： 什么是图型结构：由有穷且非空的顶点和顶点之间的边组成的集合 通常表示：G(V,E) G表示一个图，V是图中顶点(元素)的集合，E是图中边(元素与 元素之间的关系)集合 无向图： 边用(A,B)方式表示，点与点之间是互通 在无向图中，任意两个顶点之间都有边，则该无向图称为完全无向图 在有n个顶点的完全无向图中，有 n*(n-1)/2 条边 有向图： 边用<A,B>方式表示，仅表示从A点到B点的边，有向图中的边也称为弧，A是
数据结构，图（用图教你秒懂图的知识）
qq_46104786的博客
11-21 6242
数据结构学习，图（基础篇） 前言： 前面我们把树的知识全部学完了，今天我们学习图，如果不算算法，图是是我们最后一种要学的“数据结构”，图是一种非线性数据结构，它比树状结构更复杂，前面我们学习的知识都是一对一或者一对多的关系，今天要学的是多对多的关系，通常用于表示网状结构的数据。其实我们前面学过的都阔以看作特殊的图，图在很多邻域都用的到，博主之前学网络的时候广域网就是网状，就是表示不止一条通道。 每日一遍，注意休息 1.图的定义 无论多么复杂的图都是由顶点和边构成的，采用形式化的定义，图G（Graph）由两
数据结构之图的基础知识（一）
m0_63932570的博客
04-26 591
今天我们翻开新的篇章，来看一看另一种全新的数据结构——图。图是多对多的关系，在平时也是经常见到的，应用也很广泛，后面我们要讲到的生成树和最短路径，拓扑排序都与图的内容有关。 下面一起来看看图的基础知识吧 1.概念： 图是由顶点的有穷非空集合和顶点之间边的集合组成，表示为G（V,E），其中G表示一个图，V是图G中顶点的集合，E是图G中边的集合。 若顶点vi到vj之间的边没有方向，则这条边为无向边，表示为（vi，vj）或（vj，vi），反之为有向边（或弧），表示为＜vi，vj＞，其中vi称为弧尾，vj称
数据结构学习笔记——单链表
12-21
链表（linked list）是一种在物理上非连续，非顺序的数据结构，由若干节点（node）组成 单链表每一个节点又包含两部分，1是存放数据的变量data，2是存放指向下一个结点的指针next 双向链表每一个节点包含三部分，在...
数据结构实验——字符串相关操作
05-13
本人本科学习期间数据结构的第三个实验 1、实现串赋值、串比较、求串长、串联接、求子串以及串匹配（KMP算法） 2、能利用上述实现的基本操作完成置换Replace (&S, T, V)以及从串中删除一段子串StrDelete(&S,pos,len)...
text2:数据结构学习——代码实现
05-12
text2 栈
数据结构实验——赫夫曼树相关
05-13
本人本科期间学习数据结构写的实验，内容如下 1、输入一段报文，例如： CAST CAST SAT AT A TASA 统计字符集合 { C, A, S, T }，以及各个字符出现的频度(次数) W＝{ 2, 7, 4, 5 }。 2、建赫夫曼树，并输出...
数据结构学习笔记——使用draw.io绘制的树结构图
04-29
树结构 draw.io图 二叉树、顺序树、树的链式存储结构、树的数组存储结构、欧拉树 绘图软件为免费开源软件draw.io
数据结构图的学习
qq_56350439的博客
11-19 1214
1：有向图无向图的创建和输出 #include<iostream> #include<algorithm> using namespace std; #define MAX_VERTEXT_NUM 20 typedef struct ArcNode{//弧的结构 int adjvex;//该弧所指向的顶点位置 struct ArcNode *nextarc;//指向下一条弧 }ArcNode; typedef struct VNode{//顶点结构 cha
数据结构_图(1)
LIUUGNAY的博客
11-02 450
图知识框架图的基本概念有向图无向图简单图多重图完全图（也称简单完全图）子图连通、连通图和连通分量强连通图、强连通分量生成树、生成森林顶点的度、入度和出度 知识框架 图的基本概念 有向图 若E是有向边（也称为弧）的有限集合时，则图G为有向图。弧是顶点的有序对，记为<v, w>，其中v、w是顶点，v称为弧尾，w称为弧头，称为从顶点v到顶点w的弧，也称v邻接到w，或w邻接自v。 如上有向图可表示为： G1=(V1,E1)G_1 = (V_1, E_1)G1​=(V1​,E1​) V1=V_1=V1
数据结构基础：图结构的学习笔记
IT技术分享社区
09-13 479
1、图的定义图是比树更加复杂的数据结构，在图的结构当中，任意两个节点之间都有可能有直接关系，所以图中一个节点的前驱和后继的数目是没有限制的。2、图的用途用于描述各种复杂的数据对象，在自然...
数据结构学习之：图
shun12580的博客
07-25 161
定义： 堆是一种比较特殊的数据结构，可以被看做一棵树的数组对象，具有以下的性质： 堆中某个节点的值总是不大于或不小于其父节点的值； 堆总是一棵完全二叉树。 将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。 特点： 堆的定义如下：n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时，称之为堆。 (ki <= k2i,ki &...
数据结构学习—图
u010679043的博客
06-23 389
1、什么是图？ ​ 图是右顶点的有穷非空集合和顶点之间的集合组成 ，通常表示为：G（V,E），其中G表示一个图，V是图G的顶点的集合，E是图G中边的集合。我们只要记得，在图形结构中，结点之间的关系可以是任意的，因此图是多对多的关系。 2、图的各种定义 ​ 无向边：若顶点Vi到Vj之间的边没有方向，则称这条边为无向边，用无序偶对（Vi,Vj）来表示。如果图中任意两个顶点之间的边...
数据结构学习-【图】
qq_37306041的博客
12-04 404
一、图的定 在说图的定义之前 先要说明一下: 线性表中我们把数据元素叫做元素，树中数据元素叫做结点，在图中数据元素，我们称之为顶点。 下面说一下图的定义： 图是由顶点的有穷非空集合和顶点之间的集合组成，通常表示为：G(V,E)，其中，G表示一个图,V是图G中顶点的集合，E是图G中边的集合。 注意：图中的 顶点集合不允许为空，但是边集合允许为空。 各种图的定义...
数据结构之图学习笔记
我...你知道吗? 的博客
10-04 605
一、图的定义：     图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G（V,E），其中，G表示一个图，V表示图G中顶点的集合，E是图G中的边集合。     a.线性表中的数据元素我们称为元素，树中数据元素称为节点，而图中的数据元素我们称作顶点（Vertex）     b.图中任意两个顶点之间都可能有关系，顶点之间的逻辑关系用边来表示，边集可以是非空的。 1.无...
数据结构学习笔记：图
(づ｡◕‿‿◕｡)づgigi奋斗在前端和刷题中╮(╯﹏╰)╭
09-26 535
定义图G是由顶点的有穷集合，以及顶点之间的关系组成，顶点的集合记为V，顶点之间的关系构成边的集合E，G=(V,E).如果给图的每条边规定一个方向，那么得到的图称为有向图，其边也称为有向边。在有向图中，与一个节点相关联的边有出边和入边之分，而与一个有向边关联的两个点也有始点和终点之分。 相反，边没有方向的图称为无向图。图的存储 邻接表 需要保存一个顺序存储的顶点表和每个顶点上的边的链接表。 相邻
数据结构学习笔记——图
zhao_h的博客
06-06 1242
一：基本概念图（Graph）：用边连接在一起的顶点的集合。G=(V,E)，其中V的元素称为顶点，E的元素称为边。顶点（vertices）：图中的节点，存放数据。边（edge）：（i，j）表示顶点i和顶点j之间的边。无向边（undirected edge）：（i，j）和（j，i）表示的含义一样。有向边（directed edge）：（i，j）表示从顶点i到顶点j的边，（j，i）表示从顶点j到顶点i的...
《数据结构与算法——c++版》
最新发布
08-11
《数据结构与算法——c 版》是一本介绍数据结构和算法的学习教材。这本书以C语言为主要编程语言，全面讲解了数据结构和算法的基本概念及其常见的应用。通过学习本书，读者可以掌握C语言中常用的数据结构和算法，提高...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值