[数据结构]第七章-图(读书笔记2)

最新推荐文章于 2022-08-12 22:10:41 发布
最新推荐文章于 2022-08-12 22:10:41 发布
阅读量1.1k 收藏 1
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Last_Impression/article/details/12352227
版权

7.2.2 邻接表
邻接表(Adjacency List)是图的一种链式存储结构。在邻接表中，对图中每个定点建立一个单链表，第i个单链表中的结点表示依附于顶点v的边。每个结点由3个域组成，其中邻接点域(adjvex)指示与顶点v邻接的点在图中的位置，链域(nextarc)指示下一条边或弧的结点。数据域(info)存储和边或弧相关的信息，如权值等。

#include "stdafx.h"
#include <string.h>
#include <stdlib.h>
#include "c1.h"
#define MAX_VERTEX_NUM 20 

typedef enum{
	DG = 0,
	DN,
	AG,
	AN
}GraphKind; /* {有向图,有向网,无向图,无向网} */

#define MAX_NAME 3 /* 顶点字符串的最大长度+1 */
typedef int InfoType; /* 存放网的权值 */
typedef char VertexType[MAX_NAME]; /* 字符串类型 */

typedef struct ArcNode{
	int adjvex;				/*该弧所指向的顶点的位置*/
	struct ArcNode *nextarc;/* 指向下一条弧的指针 */
	InfoType *info;			/* 网的权值指针） */
}ArcNode;/* 表结点 */

typedef struct{
	VertexType data;/* 顶点信息 */
	ArcNode *firstarc;/* 第一个表结点的地址,指向第一条依附该顶点的弧的指针 */
}VNode,AdjList[MAX_VERTEX_NUM];

typedef struct{
	AdjList vertices;/*图*/
	int vexnum,arcnum;/* 图的当前顶点数和弧数 */
	int kind;/* 图的种类标志 */
}ALGraph;

int LocateVex(ALGraph G,VertexType u)
{	/* 初始条件: 图G存在,u和G中顶点有相同特征 */
	/* 操作结果: 若G中存在顶点u,则返回该顶点在图中位置;否则返回-1 */
	int i;

	for(i = 0; i < G.vexnum; i++){
		if (strcmp(u,G.vertices[i].data) == 0){
			return i;
		}
	}
	return -1;
}
Status CreateGraph(ALGraph *G)
{ /* 采用邻接表存储结构,构造没有相关信息的图G(用一个函数构造4种图) */
	int i,j,k;
	int w; /* 权值 */
	VertexType va,vb;
	ArcNode *p;

	printf("请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
	scanf("%d",&(*G).kind);
	printf("请输入图的顶点数,边数:");
	scanf("%d,%d", &(*G).vexnum, &(*G).arcnum);
	printf("请输入%d个顶点的值(<%d个字符):\n",(*G).vexnum, MAX_NAME);
	for(i=0; i < (*G).vexnum; ++i){
		scanf("%s",&(*G).vertices[i].data);	
		(*G).vertices[i].firstarc = NULL;
	}
	if((*G).kind == DN ||(*G).kind == AN){ /* 网 */
		printf("请顺序输入每条弧(边)的权值、弧尾和弧头(以空格作为间隔):\n");
	}
	else{ /* 图 */
		printf("请顺序输入每条弧(边)的弧尾和弧头(以空格作为间隔):\n");
	}
	for(k = 0; k < (*G).arcnum; ++k){ /* 构造表结点链表 */
		if ((*G).kind == AN || (*G).kind == DN){/*网*/
			scanf("%d%s%s",&w,va,vb);
		}
		else{
			scanf("%s%s",va,vb);
		}
		i = LocateVex(*G,va);/* 弧尾 */
		j = LocateVex(*G,vb);/* 弧头 */
		p = (ArcNode*)malloc(sizeof(ArcNode));
		p->adjvex = j;
		if ((*G).kind == AN || (*G).kind == DN){/*网*/
			p->info = (int*)malloc(sizeof(int));
			*(p->info) = w;
		}
		else{
			p->info = NULL;/*图*/
		}
		p->nextarc = (*G).vertices[i].firstarc;/*插在表头*/
		(*G).vertices[i].firstarc = p;
		/* 无向图或网,产生第二个表结点 */
		if((*G).kind == AG || (*G).kind == AN ){ 
			p = (ArcNode*)malloc(sizeof(ArcNode));
			p->adjvex = i;
			if((*G).kind == AN){ /* 无向网 */
				p->info = (int*)malloc(sizeof(int));
				*(p->info) = w;
			}
			else{
				p->info = NULL; /* 无向图 */
			}
			p->nextarc = (*G).vertices[j].firstarc;/*插在表头*/
			(*G).vertices[j].firstarc = p;
		}
	}
	return OK;
}
void DestroyGraph(ALGraph *G)
{ /* 初始条件: 图G存在。操作结果: 销毁图G */
	int i;
	ArcNode *p,*q;	

	for (i = 0; i < (*G).vexnum; ++i){
		p = (*G).vertices[i].firstarc;
		while(p){
			q = p->nextarc;
			if ((*G).kind == AN || (*G).kind == DN){
				free(p->info);
			}
			free(p);
			p = q;
		}
	}
	(*G).vexnum = 0;
	(*G).arcnum = 0;
}
VertexType* GetVex(ALGraph G,int v)
{/* 初始条件: 图G存在,v是G中某个顶点的序号。操作结果: 返回v的值 */
	if (v >= G.vexnum || v < 0){
		exit(ERROR);
	}
	return &G.vertices[v].data;
}

Status PutVex(ALGraph *G,VertexType v,VertexType value)
{	/* 初始条件: 图G存在,v是G中某个顶点 */
	/* 操作结果: 对v赋新值value */
	int i;
	i = LocateVex(*G, v);
	if(i > -1){ /* v是G的顶点 */
		strcpy((*G).vertices[i].data,value);
		return OK;
	}
	return ERROR;
}
int FirstAdjVex(ALGraph G,VertexType v)
{	/* 初始条件: 图G存在,v是G中某个顶点 */
	/* 操作结果: 返回v的第一个邻接顶点的序号。若顶点在G中没有邻接顶点,则返回-1 */
	ArcNode *p;
	int v1;
	v1 = LocateVex(G,v);
	p = G.vertices[v1].firstarc;
	if( p != NULL ){
		return p->adjvex;
	}
	else{
		return -1;
	}
}
int NextAdjVex(ALGraph G,VertexType v,VertexType w)
{	/* 初始条件: 图G存在,v是G中某个顶点,w是v的邻接顶点 */
	/* 操作结果: 返回v的(相对于w的)下一个邻接顶点的序号。 */
	/*           若w是v的最后一个邻接点,则返回-1 */
	ArcNode *p;
	int v1,w1;
	v1 = LocateVex(G,v);/* v1为顶点v在图G中的序号 */
	w1 = LocateVex(G,w);/* w1为顶点w在图G中的序号 */
	p = G.vertices[v1].firstarc;
	p = p->nextarc;
	while (p || p->adjvex != w1){/* 指针p不空且所指表结点不是w */
		p = p->nextarc;
	}
	if( !p || !p->nextarc ){/* 没找到w或w是最后一个邻接点 */
		return -1;
	}
	else{
		return p->nextarc->adjvex;/* 返回v的(相对于w的)下一个邻接顶点的序号 */
	}
}
void InsertVex(ALGraph *G,VertexType v)
{	/* 初始条件: 图G存在,v和图中顶点有相同特征 */
	/* 操作结果: 在图G中增添新顶点v(不增添与顶点相关的弧,留待InsertArc()去做) */
	strcpy((*G).vertices[(*G).vexnum].data, v);
	(*G).vertices[(*G).vexnum].firstarc = NULL;
	(*G).vexnum++;
}
Status DeleteVex(ALGraph *G,VertexType v)
{	/* 初始条件: 图G存在,v是G中某个顶点 */
	/* 操作结果: 删除G中顶点v及其相关的弧 */
	int i,j;
	ArcNode *p,*q;

	j = LocateVex(*G,v); /* j是顶点v的序号 */
	if (j < 0){ /* v不是图G的顶点 */
		return ERROR;
	}
	p = (*G).vertices[j].firstarc;/* 删除以v为出度的弧或边 */
	while(p){
		q = p;
		p = p->nextarc;
		if( (*G).kind== AN || (*G).kind == DN ){ /* 网 */
			free(q->info);
		}
		free(q);
		(*G).arcnum--;/* 弧或边数减1 */
	}
	(*G).vexnum--;/* 顶点数减1 */
	for(i = j; i < (*G).vexnum; i++){
		(*G).vertices[i] = (*G).vertices[i+1];
	}
	for(i=0;i < (*G).vexnum; i++){/* 删除以v为入度的弧或边且必要时修改表结点的顶点位置值 */
		p = (*G).vertices[i].firstarc;/* 指向第1条弧或边 */
		while(p){/* 有弧 */
			if(p->adjvex == j){
				if(p==(*G).vertices[i].firstarc){ /* 待删结点是第1个结点 */
					(*G).vertices[i].firstarc = p->nextarc;
					if((*G).kind == AN || (*G).kind == DN){/*网*/
						free(p->info);
					}
					free(p);
					p = (*G).vertices[i].firstarc;
					if((*G).kind == AN || (*G).kind == AG){ /* 有向 */
						(*G).vexnum--;/* 弧或边数减1 */
					}
				}
				else{
					q->nextarc = p->nextarc;
					if((*G).kind == AN || (*G).kind == DN){/*网*/
						free(p->info);
					}
					free(p);
					p=q->nextarc;
					if((*G).kind == AN || (*G).kind == AG){ /* 有向 */
						(*G).vexnum--;/* 弧或边数减1 */
					}
				}
			}
			else{
				if (p->adjvex > j){
					p->adjvex--; /* 修改表结点的顶点位置值(序号) */
				}
				q = p;
				p = p->nextarc;
			}//if(p->adjvex == j)
		}//while
		
	}
	return OK;
}

Status InsertArc(ALGraph *G,VertexType v,VertexType w)
{	/* 初始条件: 图G存在,v和w是G中两个顶点 */
	/* 操作结果: 在G中增添弧<v,w>,若G是无向的,则还增添对称弧<w,v> */
	ArcNode *p;
	int w1,i,j;

	i = LocateVex(*G,v);/* 弧尾或边的序号 */
	j = LocateVex(*G,w);/* 弧头或边的序号 */
	if(i < 0 || j < 0){
		return ERROR;
	}
	(*G).arcnum++;/* 图G的弧或边的数目加1 */
	if ((*G).kind == AN || (*G).kind == DN){
		printf("请输入弧(边)%s→%s的权值: ",v,w);
		scanf("%d",&w1);
	}
	p = (ArcNode*)malloc(sizeof(ArcNode));
	p->adjvex = j;	
	if ((*G).kind == AN || (*G).kind == DN){
		p->info = (int*)malloc(sizeof(int));
		*(p->info) = w1;
	}
	else{
		p->info = NULL;
	}
	p->nextarc = (*G).vertices[i].firstarc;/* 插在表头 */
	(*G).vertices[i].firstarc = p;
	if((*G).kind == DG || (*G).kind == DN){ /* 无向,生成另一个表结点 */
		p = (ArcNode*)malloc(sizeof(ArcNode));
		p->adjvex = i;
		if( (*G).kind == DN ){ /* 无向网 */
			p->info = (int*)malloc(sizeof(int));
			*(p->info) = w1;
		}
		else{
			p->info = NULL;
		}
		p->nextarc = (*G).vertices[j].firstarc;/* 插在表头 */
		(*G).vertices[j].firstarc = p;
	}
	return OK;
}

Boolean visited[MAX_VERTEX_NUM]; /* 访问标志数组(全局量) */
void(*VisitFunc)(char* v); /* 函数变量(全局量) */
void DFS(ALGraph G,int v)
{ /* 从第v个顶点出发递归地深度优先遍历图G。算法7.5 */
	int w;
	VertexType v1,w1;
	strcpy(v1, *GetVex(G,v));
	visited[v] = TRUE;/* 设置访问标志为TRUE(已访问) */
	VisitFunc(G.vertices[v].data);/* 访问第v个顶点 */
	for(w = FirstAdjVex(G,v1);w>=0;w = NextAdjVex(G,v1,*GetVex(G,v))){
		if (!visited[w]){
			DFS(G,w);/* 对v的尚未访问的邻接点w递归调用DFS */
		}
	}
}
void DFSTraverse(ALGraph G,void(*Visit)(char*))
{	/* 对图G作深度优先遍历。算法7.4 */
	int v;
	VisitFunc=Visit; /* 使用全局变量VisitFunc,使DFS不必设函数指针参数 */
	for(v=0;v < G.vexnum; v++){/* 访问标志数组初始化 */
		visited[v] = FALSE;
	}
	for(v=0;v < G.vexnum; v++){
		if(!visited[v]){
			DFS(G,v);/* 对尚未访问的顶点调用DFS */
		}
	}
	printf("\n");
}

void Display(ALGraph G)
{	/* 输出图的邻接矩阵G */
	int i;
	ArcNode *p;
	switch(G.kind)
	{
	case DG:
		printf("有向图\n");
		break;
	case AG:
		printf("无向图\n");
		break;
	case DN:
		printf("有向网\n");
		break;
	case AN:
		printf("无向网\n");
		break;
	}
	printf("%d个顶点：\n", G.vexnum);
	for(i=0; i < G.vexnum; i++){
		printf("%s",G.vertices[i].data);
	}
	printf("\n%d条弧(边):\n",G.arcnum);
	for(i=0; i < G.vexnum; i++){
		p = G.vertices[i].firstarc;
		while (p != NULL){
			if(G.kind == DG || G.kind == DN){
				printf("%s→%s ",G.vertices[i].data,G.vertices[p->adjvex].data);
				if (G.kind == DN){
					printf(":%d ",*(p->info));	
				}
			}
			else{ /* 无向(避免输出两次) */
				if(i<p->adjvex){
					printf("%s→%s ",G.vertices[i].data,G.vertices[p->adjvex].data);
				}
				if(G.kind == AN){ /* 网 */
					printf(":%d ",*(p->info));
				}
			}
			p = p->nextarc;
		}
		printf("\n");
	}
}
Status DeleteArc(ALGraph *G,VertexType v,VertexType w)
{	/* 初始条件: 图G存在,v和w是G中两个顶点 */
	/* 操作结果: 在G中删除弧<v,w>,若G是无向的,则还删除对称弧<w,v> */
	ArcNode *p,*q;
	int i,j;
	i = LocateVex(*G,v);/* i是顶点v(弧尾)的序号 */
	j = LocateVex(*G,w);/* j是顶点w(弧头)的序号 */
	if (i < 0 ||j < 0 || i == j){
		return ERROR;
	}
	/* p指向顶点v的第一条出弧 */
	p = (*G).vertices[i].firstarc;
	while(p != NULL && p->adjvex != j){
		q = p;
		p = p->nextarc;
	}
	if (p != NULL && p->adjvex == j){/* 找到弧<v,w> */
		if (p == (*G).vertices[i].firstarc){/* p所指是第1条弧 */
			(*G).vertices[i].firstarc = p->nextarc;/* 指向下一条弧 */
		}
		else{
			q->nextarc = p->nextarc;/* 指向下一条弧 */
		}
		if ((*G).kind == AN || (*G).kind == DN){/* 网 */
			free(p->info);
		}
		free(p);/* 释放此结点 */
		(*G).arcnum--;/* 弧或边数减1 */
	}
	/* 无向,删除对称弧<w,v> */
	if((*G).kind == AG || (*G).kind == AN){ 
		p = (*G).vertices[j].firstarc;
		while(p != NULL && p->adjvex != i){
			q = p;/* p指向下一条弧 */
			p = p->nextarc;
		}
		if(p != NULL && p->adjvex != i){
			if (p == (*G).vertices[j].firstarc){/* p所指是第1条弧 */
				(*G).vertices[j].firstarc = p->nextarc;/* 指向下一条弧 */
			}
			else{
				q->nextarc = p->nextarc;
			}
			if ((*G).kind == AN){
				free(p->info);
			}
			free(p);/* 释放此结点 */
		}
	}
	return OK;
}
进击的横打
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
计算机网络-谢希仁-第五版-读书笔记.docx
12-21
在本文中，我们将对计算机网络的基本概念、网络体系结构、物理层、数据链路层、网络层、传输层、会话层、表示层、应用层等进行详细的介绍，并对相关的知识点进行总结。 一、计算机网络的基本概念 计算机网络是指...
MYSQL必知必会读书笔记第七章之数据过滤
12-15
在MySQL中，数据过滤是...随着对SQL语言的深入学习，如第一章至第十一章的笔记所涵盖的基础、版本更改、数据库操作、数据检索、排序、过滤、通配符使用以及函数应用等，将能更全面地掌握MySQL数据库管理的各个方面。
《大话数据结构》第七章：图（笔记）
weixin_42367960的博客
12-20 357
第七章：图 学好了图，基本就等于理解了数据结构的精神 图（Graph）：是由顶点的有穷非空集合和顶点之间边的集合组成，通常为G（V，E），其中，G是表示一个图，V（Vertex）是图G中顶点的集合，E（Edge）是图G中边的集合。 图的定定义与术语： 按照有无方向，分为无向图与有向图，无向图由顶点和边构成，有向图由顶点和弧构成，弧有弧尾弧头。 按照边或者弧的多少，分为稀疏图和稠密图。如果任意两个人顶点之间都存在边叫完全图，有向的叫做有向完全图。若无重复的边或顶点到自身的边则叫简单图（顶点不重复）。 图中顶
读书笔记之《数据结构》---第七章 图
qq_25744595的博客
10-25 313
本章目录 1.图的定义和术语 2.图的存储结构 3.图的遍历 4.图的连通性问题 图的定义和术语 图中的数据元素通常称为顶点， &amp;amp;amp;lt;v，w&amp;amp;amp;gt;是从v到w的一条弧，v是弧尾，w是弧头，此图称为有向图。 (v，w)表示v和w的一条边，此图为无向图。 n个顶点的图，有1/2n（n-1）条边的无向图称为完全图，有n（n-1）条弧的有向图称为有向完全图，很少条边或弧的称为稀疏图，反之称为稠密图。每条...
@查找
dc_989898的博客
11-28 428
第 7 章查找技术 本章的主要内容是: 查找的基本概念 线性表的查找技术 树表的查找技术 散列表的查找技术 . 静态查找：不涉及插入和删除操作的查找。 动态查找：涉及插入和删除操作的查找。 静态查找适用于：查找集合一经生成，便只对其进行查找，而不进行插入和删除操作，或经过一段时间的查找之后，集中地进行插入和删除等修改操作； 动态查找适用于：查找与插入和删除操作在同一个阶段进行，例如当查找成功时，要...
数据结构第七章笔记
weixin_44044521的博客
05-04 79
数据结构笔记 目录数据结构笔记第七章顺序查找算法及分析定义及实现算法分析有序表查找二分查找算法及分析冒泡排序和选择排序算法及分析冒泡排序选择排序插入排序算法及分析谢尔排序算法及分析归并排序算法及分析快速排序算法及分析 第七章 顺序查找算法及分析 定义及实现 def sequentialSearch(alist,item): pos = 0 found = False while(pos < len(alist) and not found):
MYSQL必知必会读书笔记 第一章(基础)
12-15
【MySQL必知必会读书笔记】第一章主要涵盖了数据库的基础概念，包括数据库、表、模式、列、数据类型、行和主键等核心要素。 1. **数据库**：数据库是一个有组织地存储数据的集合，它可以是文件或者一组文件，通过...
《艾略特波浪理论-市场行为的关键》读书笔记.docx
09-27
《艾略特波浪理论-市场行为的关键》读书笔记 《艾略特波浪理论-市场行为的关键》读书笔记是一份关于艾略特波浪理论的详细笔记，该理论是由拉尔夫·纳尔逊·艾略特提出的，旨在解释股票市场指数的可识别模式趋势和...
小白读《R语言实战》写的读书笔记（第五章）
最新发布
02-27
2. 数据结构：R中的核心数据结构包括向量（vector）、数据框（data frame）、矩阵（matrix）和列表（list）。数据框是R中最常用的数据结构，它由等长的列组成，每一列可以是不同类型的向量。table5_1.csv可能就是一...
链式队列，顺序队列，二叉树，图的邻接矩阵表示，图的邻接表表示
06-10
我原来实现的数据结构（C++）：链式队列，顺序队列，二叉树，图的邻接矩阵表示，图的邻接表表示。供大家学习参考！
数据结构笔记（第七章）
miss_njhl的博客
11-23 269
![线性表的查找技术： 1、顺序查找 基本思想：从线性表的一端向另一端逐个将关键码与 给定值进行比较，若相等，则查找成功，给出该记录 在表中的位置；若整个表检测完仍未找到与给定值相 等的关键码，则查找失败，给出失败信息。 顺序查找 （线性查找） int SeqSearch1(int r[ ], int n, int k) //数组r[1] ~ r[n]存放查找集合 { i=n; while (i&...
数据结构笔记 第七章
skyriverandsea的博客
11-27 189
一.查找的基本概念 1.查找表：由同一类型的数据元素构成的集合，是一种非常灵活的数据结构。 2.静态查找表：只对查找表进行查询某个特定的数据元素或某个特定数据元素的各种属性的操作。 3.动态查找表：对查找表进行插入或删除某个数据元素的操作。 4.查找(Search)：也称检索，是根据给定的某个值，在查找表中确定一个关键字等于给定值的记录或数据元素。查找的结果通常有两种可能： 5.查找成功：即找到满...
数据结构 第七章（学习笔记一（图））
qq_45876197的博客
11-24 901
图图的定义图的其他基本概念无向图&有向图完全图子图连通图&强连通图生成树&生成森林稀疏图&稠密图顶点的度权&网有向树路径&路径长度&回路 图的定义 图（Graph）是由顶点 (Vertex) 的有穷非空集合 和顶点之间 边 的集合组成，通常表示为：G(V, E) , 其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。 |V|表示图G中顶点的个数，也称为图G的阶；|E| 表示图G中边的条数。 V = {A，B，C，D，E},|V| = 5
《数据结构》 第七章 查找技术 笔记
a761066822的专栏
12-12 629
第七章  查找技术 【学习重点】 （1）    折半查找的过程及性能分析； （2）    二叉排序树的插入、删除和查找操作； （3）    平衡二叉树的调整方法； （4）    散列表的构造和查找方法； （5）    各种查找技术的时间性能及对比。 【学习难点】   （1）二叉排序树的删除操作；   （2）平衡二叉树的调整方法；   （3）闭散列表的删除算法。        
数据结构 第七章 查找 学习笔记
m0_61126523的博客
05-19 439
目录 一、查找的一些概念和术语 二、线性表的查找 7.1 顺序查找（暴力） 7.2 折半查找（二分查找） 7.3 分块查找 三、树表的查找 7.1 二叉排序树 7.2 平衡二叉树（AVL树） 四、散列表的查找 7.1 散列表的一些基本概念 7.2 散列函数的构造方法 7.3 处理冲突的办法 7.3.1 开放地址法 7.3.2 链地址法 一、查找的一些概念和术语 1）查找表：有同一类型的数据元素（或记录）构成的集合。由于“集合”中的数据元素之间存在着完全松散的关系，.
数据结构笔记（王道考研） 第七章：查找
zimuzi2019的博客
08-12 5968
数据结构笔记（王道考研） 第七章：查找
数据结构 第七章（学习笔记二（图的存储结构））
qq_45876197的博客
11-26 204
图的存储结构之邻接矩阵 邻接矩阵的定义 图的邻接矩阵（Adjacency Matrix） 存储方式是用两个数组来表示图。一个 一维数组存储图中顶点信息，一个 二维数组(称为邻接矩阵) 存储图中的边或弧的信息。 图的邻接矩阵实现思路 结点数为n的图G=(V)的邻接矩阵A是n x n的。 将G的顶点编号为V1,V2…Vn(数组下标) 若<Vi,Vj> ∈E，则 A [i][j] = 1，否则 A [i] [j] = 0 实例（有向图） 实例（无向图） 网的邻接矩阵实现思路 结点数为n的图G
第七章， 图 学习笔记
ZHY_ERIC的博客
02-06 517
图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,E)，其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。 图是一种较线性表和树更为复杂的数据结构。在图形结构中，结点之间的关系可以是任意的，图中任意两个元素之间都可能相关。 1、线性表中我们把数据元素叫元素，树中将数据元素叫结点，在图中数据元素，我们则称之为顶点（Vertex）。 2、线性表中可以没有数据元素，称为空表。树中可以没有结点，叫做空树。在图结构中，不允许没有顶点。在...
深入理解Linux高级环境编程：APUE读书笔记解析
"这篇读书笔记主要涵盖了《高级Linux环境编程》(Advanced Programming in the Unix Environment, APUE)的多个核心章节，包括Unix基础、标准化及实现、文件I/O、文件和目录、标准I/O库、系统数据文件和信息以及进程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

进击的横打

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值