数据结构代码整理_基于邻接表存储结构的有向图的实现(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
关注
专栏目录
算法与数据结构基础8 C++实现有向图——邻接表存储
qq_44910471的博客
04-14 973
算法与数据结构基础8 C++实现有向图——邻接表存储
邻接表存储的有向图的基本操作(C语言实现)
03-23
NULL 博文链接：https://touch-2011.iteye.com/blog/1070798
求有向图的强连通分支（邻接表存储）C++实现
pleasetojava
11-07 265
// 强连通分支（邻接表存储）.cpp : Defines the entry point for the console application. //通过二次利用深度优先搜索访问节点，每次的深度优先搜索操作不同 #include "stdafx.h" #include&lt;iostream&gt; #define MAX 100 using namespace std; //...
有向图、无向图邻接表（Adjacency List）的简单实现（C++ Graph）
最新发布
u011208918的专栏
07-03 247
有向图、无向图邻接表（Adjacency List）的简单实现，以及如何从有向图中找到所有的环
基于邻接表的有向图实现
EASYGOING45的博客
11-14 1217
基于邻接表的有向图实现 邻接表 图的链式存储结构 基于链表的相关操作 结点结构体 顶点表结点 struct VertexNode //顶点表结点 { char vertex; EdgeNode *firstEdge; }; 边表结点 struct EdgeNode //定义边表结点 { int adjvex; //临接点域(编号) EdgeNode *next; }; 图类的设计 class ALGraph { private: VertexN
实验 6：图的实验 1 -有向图的邻接表存储实现
weixin_40803490的博客
05-31 7016
一、实验目的 1、 熟练理解图的相关概念； 2、 掌握图的邻接矩阵的存储方法的实现； 3、 学会图的遍历算法 二、实验内容 1、自己确定一个简单无向图（顶点数、和相关结点信息）利用邻接矩阵来实现存储。实现图的构造，并完成： 1） 用深度优先和广度优秀两种算法对图进行遍历，输出顶点序列数据； 2） 以合理的格式，输出各个顶点的邻接点； 2、试设计一个程序，对一个有向简单图，完成上题同样的任务。 三、...
数据结构与算法实验（C++）：图的邻接表实验-代码
01-18
1）熟练掌握图的邻接表存储结构的实现； 2）熟练掌握基于邻接表的图的基本操作算法实现； 3）灵活使用有向图来解决具体的问题。 （2）实验内容： 1）定义有向图的邻接表类，封装图的基本操作算法，包括： a.创建、...
C++实现有向图邻接表的构建
08-19
本文主要介绍了C++实现有向图邻接表的构建，通过示例代码详细介绍了有向图邻接表的构建过程。下面是对标题、描述、标签和部分内容的详细解释： 一、有向图邻接表的概念 有向图邻接表是一种常用的数据结构，用于...
dg.zip_dirtddf_图 数据结构_数据结构 图_数据结构 C语言_有向图
09-23
本文将详细探讨"有向图"这一重要数据结构，并以C++编程语言为例，介绍其实现方法，包括邻接表存储结构。 有向图是一种特殊的图数据结构，其中的边是有方向的，意味着从一个节点（顶点）到另一个节点的方向是单向的...
critical_path-关键路径-邻接表有向图.zip_AdjListDirNetwork.h_C++ 有向图_buffal
09-24
本资源提供了基于邻接表有向图的C++实现，用于寻找关键路径。邻接表是一种图数据结构，它以列表的形式存储图中每个顶点的邻接顶点。在有向图中，边是从一个顶点（源）指向另一个顶点（目标）。这种表示方式特别适合...
用邻接表实现图的数据结构
01-03
用邻接表实现图的数据结构，链表方式实现，win32+vs2013
有向图邻接表基本代码.rar
07-12
有向图邻接表基本代码
基于邻接链表构建的有向图
12-14
一个完整的有向图课程设计，一共含有20个方法。分享给大家一起学习。
图的建立与遍历c++实现（邻接矩阵存储）
10-14
这是一个关于图的建立与遍历的问题，用的是c++实现，邻接矩阵作为存储
[置顶] 有向图的邻接表存储，递归和非递归的深度、广度遍历（codeblocks+gcc）...
dianyin8310的博客
04-30 113
程序功能: 1. 图的邻接表存储 2. 递归深度遍历 3. 非递归深度遍历（借助stack） 4. 递归广度遍历 5. 非递归广度遍历（借助queue） 程序中通过条件编译实现，递归与非递归的选择 //#define _RECURSION_TRAVERSE //递归遍历(将下一行...
基于邻接表的图实现
毕业作品网站
05-05 2552
初始条件是图G存在，v和w是G中两个顶点的位序，v对应G的一个顶点,w对应v的邻接顶点；NextAdjVex：遍历邻接表内的顺序表，当遍历到的头结点的关键字与输入值 u 相同时，从该顶点的邻接弧中逐个遍历，若找到邻接顶点 w 且其下一邻接点存在，则返回下一邻接点的顶点信息，否则返回 ERROR；遍历邻接表内的头结点，按顺序查找与输入值v相对应的头结点，从该顶点的邻接弧中逐个遍历，若找到邻接顶点w且其下一邻接点存在，则返回下一邻接点的顶点信息，否则返回查找失败；初始条件是图G存在，v、w是G的顶点；
图的存储结构——邻接表的实现
lseaJK的博客
06-29 3599
7.2 图的存储结构7.2.2 邻接表Adjacency List定义有向网邻接表的实现顶点结点类模板弧结点类模板有向网邻接表类模板无向图/有向图的邻接表效率对比邻接表和邻接矩阵的比较 7.2.2 邻接表Adjacency List 邻接表是邻接矩阵的改进。当图中的边数很少时，邻接矩阵中会出现大量的零元素，为了存储这些零元素，将耗费大量的存储空间。为此，可以把邻接矩阵的每一行改为一个单链表。 定义...
数据结构与算法（C语言实现） 6.图的综合应用（邻接表有向图）
CaptainUniverse_的博客
05-16 1294
数据结构与算法（C语言实现） 实验六：图的综合应用（邻接表有向图）
数据结构解析：逆邻接表在有向图中的应用-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、付费专栏及课程。

余额充值