数据结构代码整理_基于邻接表存储结构的有向图的实现(C++)

最新推荐文章于 2024-07-03 11:57:05 发布
最新推荐文章于 2024-07-03 11:57:05 发布
阅读量1.9k 收藏 14
点赞数 2
分类专栏： 传统算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43510916/article/details/106460224
版权

目录

Requirements

       基于邻接表存储结构实现有向图的典型操作（构造、析构、增加顶点、删除顶点、增加弧、删除弧，查找一个 顶点、判空、判满、图中顶点个数、邻接表中指定顶点的第一个邻接顶点、深度优先遍历、广度优先遍历），测试和调试程序。

Debugging Environment

visual studio 2019

Chat

之前的图论问题中对于图的存储基本上都是用的链式向前星，刚好趁着这次课程实验了解一下邻接表，可能是第一次接触邻接表还不是很熟悉的缘故吧，总觉得邻接表好像比链式向前星麻烦一点。因为只是随手写的，可能会有一些小bug，在graph.h后面还有个test.cpp文件，那个是老师是给的测试文档，我跑了一下都还ok，但是你们在使用的时候如果发现了什么不对的地方，记得评论提醒我哈。

Code

（代码仅供参考）

1.graph.h

#ifndef GRAPH_H_INCLUDED
#define GRAPH_H_INCLUDED
/* This header file contains the declarations and prototype functions for the graph ADT
class. It also contains a debugging function to print a vertex.
*/
#include<iostream>
#include<map>
#include<queue>
#include<stack>
using namespace std;
#define DEBUG 1 //On includes printVertex
template <class TYPE> struct Vertex;//存储每个顶点的信息
template <class TYPE> struct Arc;//先简单声明，存储弧的信息
template <class TYPE> struct Vertex //存图中各顶点
{
	Vertex<TYPE>* pNextVertex;//指向下一个头顶点
	TYPE data;//顶点有效信息
	int inDegree;//入度
	int outDegree;//出度
	short processed;//标识该顶点被处理的程度或状态
	Arc<TYPE>* pArc; //指向第一条弧，这里用到了 Arc，所以在前面要先简单声明下
}; // Vertex
template <class TYPE> struct Arc //存图中各弧
{
	Vertex<TYPE>* destination;//注意这里是指针，指向弧头顶点
	Arc<TYPE>* pNextArc;//指向下一条弧
}; // Arc
template <class TYPE, class KTYPE> //KTYPE 表示各顶点中关键字的类型（关键字用于查询）
class Graph
{
private:
	int count;
	Vertex<TYPE>* first;
public:
	Graph(void);
	~Graph(void);
	int insertVertex(TYPE dataIn);//插入顶点，数据域为 dataIn
	int deleteVertex(KTYPE dltKey);//删除顶点，其数据域中关键字为 dltKey
	int insertArc(KTYPE fromKey, KTYPE toKey);//插入弧，该弧从 fromKey 指向 toKey
	int deleteArc(KTYPE fromKey, KTYPE toKey);//删除弧，该弧从 fromKey 指向 toKey
	int retrieveVertex(KTYPE key, TYPE& DataOut);//查关键字为 key 的顶点，数据存入 DataOut
	int firstArc(KTYPE key, TYPE& DataOut);//查关键字为 key 的顶点所指的首弧，数据存 DataOut
	bool emptyGraph(void);//判图是否为空
	bool graphFull(void);//判图是否为满
	int graphCount(void); //返回图顶点个数
	void depthFirst(void (*process)(TYPE dataProc));//深度优先遍历
	void breadthFirst(void (*process)(TYPE dataProc)); // 广度优先遍历
#ifdef DEBUG
		// The following function is used only for debugging
		void printVertex(KTYPE key);//该方法仅在调试时使用，输出该顶点关键字
#endif
}; // Graph
template <class TYPE, class KTYPE>
Graph<TYPE, KTYPE>::Graph()
{
	count = 0;
	first = nullptr;
}
template <class TYPE, class KTYPE>
Graph<TYPE, KTYPE>::~Graph(void)
{
	Vertex<TYPE>* p = first;
	while (p) {
		Vertex<TYPE>* q = p;
		p = p->pNextVertex;
		delete q;
	}
}
template <class TYPE, class KTYPE>
int Graph<TYPE, KTYPE>::insertVertex(TYPE dataIn)//插入顶点，数据域为 dataIn
{
	Vertex<TYPE>* p = new Vertex<TYPE>;
	p->data = dataIn;
	p->inDegree = 0;
	p->outDegree = 0;
	p->pArc = nullptr;
	p->pNextVertex = nullptr;
	count++;
	Vertex<TYPE>* temp = first;
	if (!first)
		first = p;
	else {
		while (temp->pNextVertex) {
			temp = temp->pNextVertex;
		}
		temp->pNextVertex = p;
	}
	return 1;
}
template <class TYPE, class KTYPE>
int Graph<TYPE, KTYPE>::deleteVertex(KTYPE dltKey)//删除顶点，其数据域中关键字为 dltKey
{
	Vertex<TYPE>* p = first, * q = nullptr;
	while (p) {
		if (p->data.key == dltKey) {//删除节点表中的节点
			if (p->inDegree||p->outDegree)
				return -1;
			Vertex<TYPE>* temp = p;
			p = p->pNextVertex;
			if (temp == first)//头删
				first = p;
			else
				q->pNextVertex = p;
			delete temp;
			count--;
			return 1;
		}
		q = p;
		p = p->pNextVertex;
	}
	return -2;
}
template <class TYPE, class KTYPE>
int Graph<TYPE, KTYPE>::insertArc(KTYPE fromKey, KTYPE toKey)//插入弧，该弧从 fromKey 指向 toKey
{
	int flag1 = 0, flag2 = 0;
	Vertex<TYPE>* p = first, * q1 = nullptr, * q2 = nullptr;
	while (p) {
		if (p->data.key == fromKey) {
			q1 = p;
			++flag1;
		}
		if (p->data.key == toKey) {
			q2 = p;
			++flag2;
		}
		p = p->pNextVertex;
	}
	if (!flag1)
		return -2;
	if (!flag2)
		return -3;
	Arc<TYPE>* a = new Arc<TYPE>;
	a->destination = q2;
	a->pNextArc = nullptr;
	Arc<TYPE>* temp = q1->pArc;
	if (!temp)
		q1->pArc = a;
	else {
		while (temp->pNextArc)
			temp = temp->pNextArc;
		temp->pNextArc = a;
	}
	a->destination->inDegree += 1;
	q1->outDegree += 1;
	return 1;
}
template <class TYPE, class KTYPE>
int Graph<TYPE, KTYPE>::deleteArc(KTYPE fromKey, KTYPE toKey)//删除弧，该弧从 fromKey 指向 toKey
{
	int flag1 = 0, flag2 = 0;
	Vertex<TYPE>* p = first, * q1 = nullptr;
	while (p) {
		if (p->data.key == fromKey) {
			q1 = p;
			++flag1;
		}
		p = p->pNextVertex;
	}
	if (!flag1)
		return -2;
	Arc<TYPE>* q2 = q1->pArc, * temp = nullptr;
	while (q2) {
		if (q2->destination->data.key == toKey)
		{
			if (temp)
				temp->pNextArc = q2->pNextArc;
			else
				q1->pArc = q2->pNextArc;
			q2->destination->inDegree -= 1;
			q1->outDegree -= 1;
			delete q2;
			return 1;
		}
		temp = q2;
		q2 = q2->pNextArc;
	}
	return -3;
}
template <class TYPE, class KTYPE>
int Graph<TYPE, KTYPE>::retrieveVertex(KTYPE key, TYPE& DataOut)//查关键字为 key 的顶点，数据存入 DataOut
{
	Vertex<TYPE>* p = first;
	while(p){
		if (p->data.key == key) {
			DataOut = p->data;
			return 1;
		}
		p = p->pNextVertex;
	}
	return 0;
}
template <class TYPE, class KTYPE>
int Graph<TYPE, KTYPE>::firstArc(KTYPE key, TYPE& DataOut)//查关键字为 key 的顶点所指的首弧，数据存 DataOut
{
	Vertex<TYPE>* p = first;
	while (p) {
		if (p->data.key == key) {
			if (p->pArc) {
				DataOut = p->pArc->destination->data;
				return 1;
			}
			return -1;
		}
		p = p->pNextVertex;
	}
	return -2;
}	
template <class TYPE, class KTYPE>
bool Graph<TYPE, KTYPE>::emptyGraph(void)//判图是否为空
{
	return count == 0;
}
template <class TYPE, class KTYPE>
bool Graph<TYPE, KTYPE>::graphFull(void)//判图是否为满
{
	return false;
}
template <class TYPE, class KTYPE>
int Graph<TYPE, KTYPE>::graphCount(void) //返回图顶点个数
{
	return count;
}
template <class TYPE, class KTYPE>
void Graph<TYPE, KTYPE>::depthFirst(void (*process)(TYPE dataProc))//深度优先遍历
{
	if (first) {
		Vertex<TYPE>* p = first;
		int cnt = 0;
		stack<Arc<TYPE>* >st;
		while (p) {//标记置位
			p->processed = 0;
			p = p->pNextVertex;
		}
		p = first;
		while (!st.empty() || cnt == 0) {
			Vertex<TYPE>* ptemp = first;
			if (cnt != 0) {
				ptemp = st.top()->destination;
				st.pop();
			}
			process(ptemp->data);
			Arc<TYPE>* temp = ptemp->pArc;
			while (temp) {
				if (!temp->destination->processed) { //遇到当前弧表的未处理弧
					st.push(temp);
					temp->destination->processed = 1;
				}
				temp = temp->pNextArc;
			}
			cnt++;
		}
	}
}
template <class TYPE, class KTYPE>
void Graph<TYPE, KTYPE>::breadthFirst(void (*process)(TYPE dataProc)) // 广度优先遍历
{
	if (first) {
		Vertex<TYPE>* p = first;
		Arc<TYPE>* a = p->pArc;
		queue<Vertex<TYPE>* > q;
		while (p) {//初始化
			p->processed = 0;
			p = p->pNextVertex;
		}
		if (first)
			q.push(first);
		while (!q.empty()) {
			Vertex<TYPE>* ptemp = q.front();
			q.pop();
			if (!ptemp->processed) {
				process(ptemp->data);
				ptemp->processed = 1;
			}
			Arc<TYPE>* temp = ptemp->pArc;
			while (temp) {
				if (!temp->destination->processed)
				{
					process(temp->destination->data);
					temp->destination->processed = 1;
					q.push(temp->destination);
				}
				temp = temp->pNextArc;
			}
		}
	}
}
template <class TYPE, class KTYPE>
void Graph<TYPE, KTYPE>::printVertex(KTYPE key)//该方法仅在调试时使用，输出该顶点关键字
{
	Vertex<TYPE>* p = first;
	while (p) {
		if (p->data.key == key) {
			cout << "Adjacency list for " << key;
			cout << " " << "inDegree " << p->inDegree << "--outDegree " << p->outDegree << endl;
			Arc<TYPE>* temp = p->pArc;
			while (temp) {
				cout << " " << temp->destination->data.key;
				temp = temp->pNextArc;
			}
			break;
		}
		p = p->pNextVertex;
	}
}

#endif // GRAPH_H_INCLUDED

2.test.cpp

/* This program tests the graph ADT */
#include <iostream>
#include <iomanip>
#include <ctype.h>
#include <stdlib.h>
#include <limits.h>
#include "graph.h"
using namespace std;
struct DATA
{
	int key;
	bool operator<(const DATA& p)const {
		return key < p.key;
	}
};
//Prototype Functions
void doInsertVertex(Graph<DATA, int>& graph);
void doInsertArc(Graph<DATA, int>& graph);
void doDeleteVertex(Graph<DATA, int>& graph);
void doDeleteArc(Graph<DATA, int>& graph);
void search(Graph<DATA, int>& graph);
void doRetrieveVertex(Graph<DATA, int>& graph);
void doFirstArc(Graph<DATA, int>& graph);
void testUtilties(Graph<DATA, int>& graph);
void buildAGraph(Graph<DATA, int>& graph);
char doMenu(void);
void process(DATA data);
int main(void)
{ // Local Declarations
	char option;
	int key;
	DATA datum;
	Graph<DATA, int> graph;
	// Statements
	cout << "Start Explore Graphs\n";
	while ((option = doMenu()) != 'q')
	{
		switch (option)
		{
		case 'i': doInsertVertex(graph); break;
		case 'd': doDeleteVertex(graph); break;
		case 'a': doInsertArc(graph); break;
		case 'b': doDeleteArc(graph); break;
		case 'p': cout << "Enter vertex key: ";
			cin >> key;
			graph.printVertex(key);
			break;
		case 'r': doRetrieveVertex(graph); break;
		case 's': doFirstArc(graph); break;
		case 't': datum.key = INT_MIN;
				process(datum);//Set count
			cout << "\nBegin depth first traversal\n";
			graph.depthFirst(process);
			cout << "\nEnd depth first traversal\n";
			cout << "\nBegin breadth first traversal\n";
			process(datum); //Set count
			graph.breadthFirst(process);
			cout << "\nEnd breadth first traversal\n";
			break;
		case 'x': testUtilties(graph); break;
		case '!': buildAGraph(graph); break;
		default: cout << "\a\a\nInvalid option. Please try again.\n";
		} // switch
	} // while
	return 0;
	cout << "End Explore Graphs\n";
} // main
/* ============================= doMenu =============================
This function prints a menu and reads the user selection.
Pre Nothing.
Post option returned.
*/
char doMenu(void)
{ // Local Declarations
	char option;
	// Statements
	cout << "\n============ Menu =============\n";
	cout << " i : Insert new item \n";
	cout << " d : Delete a vertex \n";
	cout << " a : Insert an arc \n";
	cout << " b : Delete an arc \n";
	cout << " p : Print Vertex Adjacency \n";
	cout << " r : Retrieve Vertex \n";
	cout << " s : Retrieve First Arc \n";
	cout << " t : Traverse graph \n";
	cout << " x : Test ADT utilities \n";
	cout << " q : Quit \n\n";
	cout << "=============================== \n";
	cout << "Please enter your choice: ";
	cin >> option;
	option = tolower(option);
	return option;
} // doMenu
/* =================== doRetrieveVertex ===================
This function locates a vertex in the graph.
Pre graph exists.
Post vertex retrieved and printed.
*/
void doRetrieveVertex(Graph<DATA, int>& graph)
{ // Local Declarations
	int key;
	int success;
	DATA dataOut;
		// Statements
		cout << "Please enter key to be found: ";
	cin >> key;
	success = graph.retrieveVertex(key, dataOut);
	if (success == 1)
		cout << "\nKey found. Contains " << dataOut.key << endl;
	else
		cout << "\n\aKey " << key << " not found\n";
	return;
} // doRetrieveVertex
/* =================== doFirstArc ===================
This function locates the first arc of a vertex.
Pre graph exists.
Post vertex first arc retrieved and printed.
*/
void doFirstArc(Graph<DATA, int>& graph)
{ // Local Declarations
	int key;
	int success;
	DATA dataOut;
	// Statements
	cout << "Please enter key of first arc: ";
	cin >> key;
	success = graph.firstArc(key, dataOut);
	if (success == 1)
		cout << "\nFirst arc of " << key << " contains " << dataOut.key;
	else if (success == -2)
		cout << "\n\aVertex Key " << key << " not found\n";
	else
		cout << key << " has no arcs\n";
	return;
} // doFirstArc
/* ===================== doInsertVertex =====================
This function gets input from the user and passes it to
vertex insert vertex function.
Pre graph exists.
Post vertex has been inserted.
*/
void doInsertVertex(Graph<DATA, int>& graph)
{ // Prototype Statements
// Local Declarations
	DATA newData;
	int success;
	// Statements
	cout << "\nPlease enter interger to be inserted: ";
	cin >> newData.key;
	success = graph.insertVertex(newData);
	if (success)
		cout << newData.key << " inserted\n";
	else
		cout << newData.key << " NOT inserted\a\n";
	return;
} // doInsertVertex
/* ======================= doInsertArc =======================
This function gets input from the user and passes it to
arc insert vertex function.
Pre graph exists.
Post arc has been inserted.
*/
void doInsertArc(Graph<DATA, int>& graph)
{
	// Prototype Statements
	// Local Declarations
	int fromKey;
	int toKey;
	int success;
	// Statements
	cout << "\nPlease enter from key: ";
	cin >> fromKey;
	cout << "\nPlease enter to key: ";
	cin >> toKey;
	success = graph.insertArc(fromKey, toKey);
	switch (success)
	{
	case 1: cout << "arc " << fromKey << "-to-" << toKey << " inserted\n";
		break;
	case -1: cout << "Overflow: arc NOT inserted\a\n";
		break;
	case -2: cout << "From Key " << fromKey << " Error\a\n";
		break;
	case -3: cout << "To Key " << toKey << " Error\a\n";
		break;
	default: cout << "Unknown error " << success << " in doInsertArc\n";
		cout << "ABORTING 100\a\a\n";
		exit(100);
	} // switch
	return;
} // doInsertArc
/* ======================= doDeleteArc =======================
This function gets input from the user and passes it to
the delete arc function.
Pre graph exists.
Post arc has been deleted.
*/
void doDeleteArc(Graph<DATA, int>& graph)
{ // Local Declarations
	int fromKey;
	int toKey;
	int success;
	// Statements
	cout << "\nPlease enter from key: ";
	cin >> fromKey;
	cout << "\nPlease enter to key: ";
	cin >> toKey;
		success = graph.deleteArc(fromKey, toKey);
	switch (success)
	{
	case 1: cout << "arc " << fromKey << "-to-" << toKey << " deleted\n";
		break;
	case -2: cout << "From Key " << fromKey << " Error\a\n";
		break;
	case -3: cout << "To Key " << toKey << " Error\a\n";
		break;
	default: cout << "Unknown error " << success << "in doDeleteArc\n";
		cout << "ABORTING 101\a\a\n";
		exit(101);
	} // switch
	return;
} // doDeleteArc
/* ========================== doDeleteVertex ==========================
This function deletes a node from the graph. It asks the user for the
key of the node to be deleted and then removes it from the graph.
Pre graph must be initialized. Null graph is OK.
Post The node is deleted and its space recylced
-or- An error message is printed.
*/
void doDeleteVertex(Graph<DATA, int>& graph)
{ // Prototype Statements
// Local Declarations
	int dltKey;
	int success;
	DATA dltData;
	// Statements
	cout << "\nPlease enter integer to be deleted: ";
	cin >> dltKey;
	graph.retrieveVertex(dltKey, dltData);//即将被删的元素读出来到 dltDat 中
	success = graph.deleteVertex(dltKey);//真正删除被删的元素
	switch (success)
	{
	case 1: cout << dltKey << " deleted\n";
		break;
	case -1: cout << dltKey << "'s degree not zero\a\n";
		break;
	case -2: cout << dltKey << "'s key not found\a\n";
		break;
	default: cout << "UNKNOWN ERROR 101 in delete\a\n";
		cout << "ABORTING\a";
		exit(101);
	} // switch
	return;
} // doDeleteVertex
/* =================== process ==================
This function "processes" a graph by printing a
sequential number and the vertex data.
Pre dataPtr is pointer to user data structure
Post Data (integer) printed.
*/
void process(DATA data)
{ // Local Declarations
	static int count = 1;
		// Statements
		if (data.key == INT_MIN)
			count = 1;
		else
			cout << "Vertex #" << setw(3) << count++
			<< " contains: " << setw(3) << data.key << endl;
	return;
} // process
/* =================== testUtilties ==================
This function tests the ADT utilities by calling
each in turn and printing their results.
Pre graph has been created.
Post Results printed.
*/
void testUtilties(Graph<DATA, int>& graph)
{
	cout << "Graph contains " << graph.graphCount() << " nodes\n";
	if (graph.emptyGraph())
		cout << "The graph IS empty\n";
	else
		cout << "The graph IS NOT empty\n";
	if (graph.graphFull())
		cout << "The graph IS full\a\n";
	else
		cout << "The graph IS NOT full\n";
	return;
} // testUtilities
/* =================== buildAGraph ==================
This function builds the graph in Figure 12-1(a)
using 1 for A, 2 for B, etc.
Pre graph has been created.
Post graph built.
*/
void buildAGraph(Graph<DATA, int>& graph)
{
	// Local Declarations
	DATA data;
	int i;
	int success;
	int fromKey;
	int toKey;
	// Statements
	for (i = 1; i <= 6; i++)
	{
		data.key = i;
		success = graph.insertVertex(data);
		if (!success)
			cout << "Insert error in buildAGraph\a\a\n", exit(100);
	} // for
	// Vertices built. Now build arcs
	fromKey = 1;
	toKey = 2;
	success = graph.insertArc(fromKey, toKey);
	fromKey = 2;
	toKey = 3;
	success = graph.insertArc(fromKey, toKey);
	fromKey = 3;
	toKey = 4;
	success = graph.insertArc(fromKey, toKey);
	fromKey = 3;
	toKey = 5;
	success = graph.insertArc(fromKey, toKey);
	fromKey = 5;
	toKey = 4;
	success = graph.insertArc(fromKey, toKey);
	fromKey = 5;
	toKey = 6;
	success = graph.insertArc(fromKey, toKey);
	fromKey = 2;
	toKey = 5;
	success = graph.insertArc(fromKey, toKey);
	if (!success)
		cout << "Error adding arcs in buildAGraph\a\a\n", exit(100);
	return;
}
chaoql
关注
专栏目录
数据结构与算法实验（C++）：图的邻接表实验-代码
01-18
1）熟练掌握图的邻接表存储结构的实现； 2）熟练掌握基于邻接表的图的基本操作算法实现； 3）灵活使用有向图来解决具体的问题。 （2）实验内容： 1）定义有向图的邻接表类，封装图的基本操作算法，包括： a.创建、...
有向图的十字链表存储表示 以及相关操作（包括增加弧、删除弧、删除顶点等）
PKG1548669491的专栏
11-29 2969
十字链表表示特点 1.针对弧结点，增加入弧链表结构和出弧链表结构； 2.容易求得任意顶点的出度和入度，专用于有向图的操作； 3.结构实现比较复杂。 基本数据结构 1.弧的数据结构 typedef struct Arc {      int tailvex;      int headvex;      st
图的邻接表实现
weixin_53459056的博客
08-28 1099
为什么使用邻接表 当图中的边数相对于顶点较少时，邻接矩阵是对存储空间的极大浪费 我们可以考虑对边或弧使用链式存储的方式来避免空间浪费的问题 我们把这种数组与链表相结合的存储方法称为邻接表 邻接表的实现 图的结构体 1.顶点数、弧数 2.图的类型 3.邻接表 typedef int ArcType; enum GraphKind { DG, DN, UDG, UDN, }; struct Vertex { char name[MAX_NAME_SIZE]; }; .
有向图、无向图邻接表（Adjacency List）的简单实现（C++ Graph）
最新发布
u011208918的专栏
07-03 247
有向图、无向图邻接表（Adjacency List）的简单实现，以及如何从有向图中找到所有的环
C语言数据结构 图 数组表示法 邻接表 以及用邻接表实现图的基础操作（删除添加顶点和弧，深度优先遍历等）
ypx1269874756的博客
11-15 1979
IDE：Visual Studio 2019 声明：为了方便书写代码，用到了C++的引用调用特性和iostream作为输入输出，读者可以使用指针调用和scanf_s/print语句实现相同效果 tips：有疑问可以在下面交流，我会尽量回复的 头文件heads.h #pragma once #include "stdio.h" #include "iostream" #define OK 1 #define TRUE 1 #define FALSE 0 #define ERROR 0 #define OVER
数据结构及算法基础 之图（二）邻接表
qigaohua的博客
10-31 718
文章目录一、邻接表二、代码实现     一、邻接表   邻接矩阵看上去是个不错的选择，首先是容易理解，第二是索引和编排都很舒服~但是我们也发现，对于边数相对顶点较少的图，这种结构无疑是存在对存储空间的极大浪费。因此我们可以考虑另外一种存储结构方式，例如把数组与链表结合一起来存储，这种方式在图结构也适用，我们称为邻接表(AdjacencyList)。 邻接表的处理方法是这样： ...
邻接表的基本操作(无向网)
weixin_30596165的博客
11-28 473
#include<iostream> using namespace std; #define MAX_VERTEX_NUM 20 #define OK 1 #define ERROR -1 typedef int InfoType; typedef int VertexType; typedef int Status; typedef enum{DG , DN, UDG,...
C++实现有向图邻接表的构建
08-19
本文主要介绍了C++实现有向图邻接表的构建，通过示例代码详细介绍了有向图邻接表的构建过程。下面是对标题、描述、标签和部分内容的详细解释： 一、有向图邻接表的概念 有向图邻接表是一种常用的数据结构，用于...
C++实现有向图的邻接表表示
08-19
C++实现有向图的邻接表表示 在计算机科学和信息技术领域中，图是一种常用的数据结构，用于描述顶点和边之间的关系。在C++中，实现有向图的邻接表表示是一种常用的方法，本文将详细介绍该方法的实现细节。 一、有向...
dg.zip_dirtddf_图 数据结构_数据结构 图_数据结构 C语言_有向图
09-23
本文将详细探讨"有向图"这一重要数据结构，并以C++编程语言为例，介绍其实现方法，包括邻接表存储结构。 有向图是一种特殊的图数据结构，其中的边是有方向的，意味着从一个节点（顶点）到另一个节点的方向是单向的...
c++实现图的操作（增删改查、遍历、最小生成树）
dancheng1的博客
12-10 1325
如果嫌复制粘贴麻烦，可以到我的资源下载：http://download.csdn.net/detail/dancheng1/9708649   这个下下来直接可以使用。   这些代码直接就可以复制粘贴进行操作（编译器：不支持 vc++6.0） 需要建立的文件有： GraphBian.cpp GraphDian.cpp PrimNum.cpp graph.h graph.cpp ...
数据结构 C++实现 有向图的邻接表存储，并输出顶点的出度
qq_54388490的博客
12-15 5343
文章目录实验内容有向图邻接表表示代码内容运行结果总结 实验内容 建立有向图的邻接表存储并求出第i个顶点的出度并输出 有向图邻接表表示 代码内容 #include<iostream> #define MVNum 100 //最大顶点数 #define OK 1; #define ERROR 0; typedef int Status; typedef char VerTexType; //顶点的数据类型定为字符型 using namespace std; //存储边的信息 typedef s
有向图和无向图用邻接矩阵储存及代码实现
F_hawk189的博客
04-04 1520
转载自：https://blog.csdn.net/vicdd/article/details/77983089 一般存储图的方式有两种：一是用邻接矩阵表示，二是用邻接链表。 所谓用邻接矩阵，是用一个二维数组存储，边使用矩阵来构建模型，这使得每一个顶点和其它顶点之间都有边的有无 的 表示的机会。若有边，则他们交点 为1 ，否则为0。当然，如果是一副边有权值的图，交点存储的是他们边的权值。 1、...
基于邻接表的有向图实现
EASYGOING45的博客
11-14 1217
基于邻接表的有向图实现 邻接表 图的链式存储结构 基于链表的相关操作 结点结构体 顶点表结点 struct VertexNode //顶点表结点 { char vertex; EdgeNode *firstEdge; }; 边表结点 struct EdgeNode //定义边表结点 { int adjvex; //临接点域(编号) EdgeNode *next; }; 图类的设计 class ALGraph { private: VertexN
算法与数据结构基础8 C++实现有向图——邻接表存储
qq_44910471的博客
04-14 973
算法与数据结构基础8 C++实现有向图——邻接表存储
实验 6：图的实验 1 -有向图的邻接表存储实现
weixin_40803490的博客
05-31 7015
一、实验目的 1、 熟练理解图的相关概念； 2、 掌握图的邻接矩阵的存储方法的实现； 3、 学会图的遍历算法 二、实验内容 1、自己确定一个简单无向图（顶点数、和相关结点信息）利用邻接矩阵来实现存储。实现图的构造，并完成： 1） 用深度优先和广度优秀两种算法对图进行遍历，输出顶点序列数据； 2） 以合理的格式，输出各个顶点的邻接点； 2、试设计一个程序，对一个有向简单图，完成上题同样的任务。 三、...
数据结构与算法（C语言实现） 6.图的综合应用（邻接表有向图）
CaptainUniverse_的博客
05-16 1294
数据结构与算法（C语言实现） 实验六：图的综合应用（邻接表有向图）
邻接表的实现（有向邻接表）、（无向邻接表），基于C++
qq_40059236的博客
02-24 5116
邻接表的介绍以及邻接表的代码实现
图的存储结构——邻接表的实现
lseaJK的博客
06-29 3599
7.2 图的存储结构7.2.2 邻接表Adjacency List定义有向网邻接表的实现顶点结点类模板弧结点类模板有向网邻接表类模板无向图/有向图的邻接表效率对比邻接表和邻接矩阵的比较 7.2.2 邻接表Adjacency List 邻接表是邻接矩阵的改进。当图中的边数很少时，邻接矩阵中会出现大量的零元素，为了存储这些零元素，将耗费大量的存储空间。为此，可以把邻接矩阵的每一行改为一个单链表。 定义...
数据结构解析：逆邻接表在有向图中的应用-C++实现
"逆邻接表——对有向图而言-C++版数据结构-张宏" 逆邻接表是一种用于表示有向图的数据结构，特别适用于实现图的深度优先搜索（DFS）或拓扑排序等操作。在有向图中，每个顶点都有指向其他顶点的边，而逆邻接表则是将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

chaoql

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

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

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

打赏作者

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

抵扣说明：

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

余额充值