第96篇 C++数据结构（六）图-领接矩阵实现

最新推荐文章于 2024-06-12 10:12:45 发布
最新推荐文章于 2024-06-12 10:12:45 发布
阅读量303 收藏 4
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49188222/article/details/124520824
版权

第96篇 C++数据结构（六）图-领接矩阵实现


本篇只是简单的实现，具体图的介绍请看其他博文。

1.图的简介

图(Graph)是由顶点的有穷非空集合 V ( G ) V(G) V(G)和顶点之间边的集合 E ( G ) E(G) E(G)组成，通常表示为: G = ( V , E ) G=(V,E) G=(V,E)，其中， G G G表示个图， V V V是图 G G G中顶点的集合， E E E是图 G G G中边的集合。若 V = { v 1 , v 2 , . . . , v n } V= {v_1, v_2,…,v_n} V={v1​,v2​,…,vn​}，则用 ∣ V ∣ |V| ∣V∣表示图 G G G中顶点的个数，也称图 G G G的阶， E = { ( u , v ) ∣ u ∈ V , v ∈ V } E= {(u, v) |u∈V, v∈V} E={(u,v)∣u∈V,v∈V}，用 ∣ E ∣ |E| ∣E∣表示图 G G G中边的条数。

1.1.大佬文章链接

数据结构：图(Graph)【详解】
这篇文章非常详细。

2.实现

2.1.变量

变量名称类型属性说明
m_pointList_PointType*私有图中点的集合
m_collarMatrix_EdgeDataType**私有图的领接矩阵
m_pointCountint私有点的个数

2.2.方法

方法名返回类型参数属性说明
Graph()-int pointCount公有传点数构造
Graph()-const Graph& G公有拷贝构造
~Graph()--公有析构函数
operator = ()Graph&const Graph& G公有=运算符重载
init()voidint pointCount公有初始化
getPointCount()int-公有返回图的点数
getEdgeCount()int-公有返回边的数量
setPoint()boolint pointIndex, _PointType pointName公有设置点的名称
addPoint()bool_PointType pointName公有添加点
removePoint()bool_PointType pointName公有删除点
addEdge()bool_PointType firstPoint, _PointType secondePoint, _EdgeDataType edgeValue公有添加边
setEdge)bool(_PointType firstPoint, _PointType secondePoint, _EdgeDataType edgeValue公有设置边
removeEdge()bool_PointType firstPoint, _PointType secondePoint公有删除边
printPoint()void-公有打印点
printGraph()void-公有打印图
DFS()void-公有深度遍历（提供外部接口）
BFS()void-公有广度优先遍历
DFS()void_EdgeDataType** collarMatrix, int currentPointIndex, bool* isVisit保护深度优先遍历
clear()void-保护清空图（释放内存）

3.测试

3.1.测试代码

只是简单的测试了一下。

#include <iostream>

#include "Graph.h"

int main()
{
	Graph<int, char> graph(8);
	for (int i = 0; i < graph.getPointCount(); i++)
	{
		graph.setPoint(i, 'a' + i);
	}

	std::cout << "构造一个有8个点的图，点的名称为：abcdefgh" << std::endl;
	graph.printPoint();
	graph.printGraph();

	std::cout << "添加7条边：" << std::endl;
	graph.addEdge('a', 'b', 1);
	graph.addEdge('a', 'c', 1);
	graph.addEdge('b', 'd', 1);
	graph.addEdge('b', 'e', 1);
	graph.addEdge('e', 'h', 1);
	graph.addEdge('c', 'f', 1);
	graph.addEdge('c', 'g', 1);
	graph.printPoint();
	graph.printGraph();

	std::cout << "深度优先搜索：" << std::endl;
	graph.DFS();
	std::cout << std::endl;

	std::cout << "广度优先搜索：" << std::endl;
	graph.BFS();
	std::cout << std::endl;

	std::cout << "边数：" << graph.getEdgeCount() << std::endl;
	std::cout << "点数：" << graph.getPointCount() << std::endl;

	std::cout << "添加一个s点：" << std::endl;
	graph.addPoint('s');
	graph.printPoint();
	graph.printGraph();

	std::cout << "添加两条边：as, ds" << std::endl;
	graph.addEdge('a', 's', 1);
	graph.addEdge('d', 's', 1);
	graph.printPoint();
	graph.printGraph();

	std::cout << "删除一条边：cf" << std::endl;
	graph.removeEdge('c', 'f');
	graph.printPoint();
	graph.printGraph();

	std::cout << "删除点f：" << std::endl;
	graph.removePoint('f');
	graph.printPoint();
	graph.printGraph();

	return 0;
}

3.2.输出结果

构造一个有8个点的图，点的名称为：abcdefgh
[a, b, c, d, e, f, g, h]
[0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0]
添加7条边：
[a, b, c, d, e, f, g, h]
[0, 1, 1, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 1, 0, 0, 0]
[1, 0, 0, 0, 0, 1, 1, 0]
[0, 1, 0, 0, 0, 0, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 1]
[0, 0, 1, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 0]
深度优先搜索：
a, b, d, e, h, c, f, g,
广度优先搜索：
a, b, c, d, e, f, g, h,
边数：7
点数：8
添加一个s点：
[a, b, c, d, e, f, g, h, s]
[0, 1, 1, 0, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 1, 0, 0, 0, 0]
[1, 0, 0, 0, 0, 1, 1, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0]
添加两条边：as, ds
[a, b, c, d, e, f, g, h, s]
[0, 1, 1, 0, 0, 0, 0, 0, 1]
[1, 0, 0, 1, 1, 0, 0, 0, 0]
[1, 0, 0, 0, 0, 1, 1, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 0, 1]
[0, 1, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 0, 0]
[1, 0, 0, 1, 0, 0, 0, 0, 0]
删除一条边：cf
[a, b, c, d, e, f, g, h, s]
[0, 1, 1, 0, 0, 0, 0, 0, 1]
[1, 0, 0, 1, 1, 0, 0, 0, 0]
[1, 0, 0, 0, 0, 0, 1, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 0, 1]
[0, 1, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 0, 0]
[1, 0, 0, 1, 0, 0, 0, 0, 0]
删除点f：
[a, b, c, d, e, g, h, s]
[0, 1, 1, 0, 0, 0, 0, 1]
[1, 0, 0, 1, 1, 0, 0, 0]
[1, 0, 0, 0, 0, 1, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 1]
[0, 1, 0, 0, 0, 0, 1, 0]
[0, 0, 1, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 0]
[1, 0, 0, 1, 0, 0, 0, 0]

4.实现代码

#pragma once
#ifndef _GRAPH_h_
#define _GRAPH_H_

#include <iostream>
#include <queue>

template <typename _EdgeDataType, typename _PointType>
class Graph
{
public:
	Graph(int pointCount)
	{
		init(pointCount);

		for (int i = 0; i < m_pointCount; i++)
		{
			m_pointList[i] = _PointType();
		}

		for (int i = 0; i < m_pointCount; i++)
		{
			for (int j = 0; j < m_pointCount ; j++)
			{
				m_collarMatrix[i][j] = _EdgeDataType();
			}
		}
	}

	Graph(const Graph& G)
	{
		init(G.m_pointCount);

		for (int i = 0; i < m_pointCount; i++)
		{
			m_pointList[i] = G.m_pointList[i];
		}

		for (int i = 0; i < m_pointCount; i++)
		{
			for (int j = 0; j < m_pointCount; j++)
			{
				m_collarMatrix[i][j] = G.m_collarMatrix[i][j];
			}
		}
	}

	~Graph()
	{
		clear();
	}

	Graph& operator = (const Graph& G)
	{
		if (m_pointCount != 0)
		{
			clear();
		}

		init(G.m_pointCount);

		for (int i = 0; i < m_pointCount; i++)
		{
			m_pointList[i] = G.m_pointList[i];
		}

		for (int i = 0; i < m_pointCount; i++)
		{
			for (int j = 0; j < m_pointCount; j++)
			{
				m_collarMatrix[i][j] = G.m_collarMatrix[i][j];
			}
		}

		return *this;
	}

	void init(int pointCount)
	{
		if (pointCount <= 0)
		{
			m_collarMatrix = nullptr;
			m_pointList = nullptr;
			m_pointCount = 0;
		}
		else
		{
			m_pointList = new _PointType[pointCount];

			m_collarMatrix = new _EdgeDataType * [pointCount];
			for (int i = 0; i < pointCount; i++)
			{
				m_collarMatrix[i] = new _EdgeDataType[pointCount];
			}

			m_pointCount = pointCount;
		}
	}

	int getPointCount() const
	{
		return m_pointCount;
	}

	int getEdgeCount() const
	{
		int edgeCount(0);
		for (int i = 0; i < m_pointCount; i++)
		{
			for (int j = i + 1; j < m_pointCount; j++)
			{
				if (m_collarMatrix[i][j] != _EdgeDataType())
				{
					edgeCount++;
				}
			}
		}

		return edgeCount;
	}

	bool setPoint(int pointIndex, _PointType pointName)
	{
		if (pointIndex < 0 || pointIndex >= m_pointCount)
		{
			return false;
		}

		for (int i = 0; i < m_pointCount; i++)
		{
			if (m_pointList[i] == pointName)
			{
				return false;
			}
		}

		m_pointList[pointIndex] = pointName;

		return true;
	}

	bool addPoint(_PointType pointName)
	{
		int pointCount = m_pointCount + 1;

		for (int i = 0; i < m_pointCount; i++)
		{
			if (m_pointList[i] == pointName)
			{
				return false;
			}
		}

		_PointType* pointList = new _PointType[m_pointCount + 1];
		for (int i = 0; i < m_pointCount; i++)
		{
			pointList[i] = m_pointList[i];
		}
		pointList[m_pointCount] = pointName;

		_EdgeDataType** collarMatrix = new _EdgeDataType*[m_pointCount + 1];
		for (int i = 0; i < m_pointCount + 1; i++)
		{
			collarMatrix[i] = new _EdgeDataType[m_pointCount + 1];
		}

		for (int i = 0; i < m_pointCount + 1; i++)
		{
			for (int j = 0; j < m_pointCount + 1; j++)
			{
				if (i < m_pointCount && j < m_pointCount)
				{
					collarMatrix[i][j] = m_collarMatrix[i][j];
				}
				else
				{
					collarMatrix[i][j] = _EdgeDataType();
				}
			}
		}

		clear();

		m_pointCount = pointCount;
		m_pointList = pointList;
		m_collarMatrix = collarMatrix;

		return true;
	}

	bool removePoint(_PointType pointName)
	{
		int pointCount = m_pointCount - 1;

		int removeIndex = 0;
		for (; removeIndex < m_pointCount; removeIndex++)
		{
			if (m_pointList[removeIndex] == pointName)
			{
				break;
			}
		}
		if (removeIndex == m_pointCount)
		{
			return false;
		}

		_PointType* pointList = new _PointType[m_pointCount - 1];
		for (int i = 0; i < m_pointCount - 1; i++)
		{
			if (i < removeIndex)
			{
				pointList[i] = m_pointList[i];
			}
			else
			{
				pointList[i] = m_pointList[i + 1];
			}
		}

		_EdgeDataType** collarMatrix = new _EdgeDataType * [m_pointCount - 1];
		for (int i = 0; i < m_pointCount - 1; i++)
		{
			collarMatrix[i] = new _EdgeDataType[m_pointCount - 1];
		}

		for (int i = 0; i < m_pointCount - 1; i++)
		{
			for (int j = 0; j < m_pointCount - 1; j++)
			{
				if (i < removeIndex && j < removeIndex)
				{
					collarMatrix[i][j] = m_collarMatrix[i][j];
				}
				else if (i < removeIndex && j >= removeIndex)
				{
					collarMatrix[i][j] = m_collarMatrix[i][j + 1];
				}
				else if (i >= removeIndex && j < removeIndex)
				{
					collarMatrix[i][j] = m_collarMatrix[i + 1][j];
				}
				else
				{
					collarMatrix[i][j] = m_collarMatrix[i + 1][j + 1];
				}
			}
		}

		clear();

		m_pointCount = pointCount;
		m_pointList = pointList;
		m_collarMatrix = collarMatrix;

		return true;
	}

	bool addEdge(_PointType firstPoint, _PointType secondePoint, _EdgeDataType edgeValue)
	{
		if (edgeValue == _EdgeDataType() || firstPoint == secondePoint)
		{
			return false;
		}

		int firstPointIndex = 0;
		for (; firstPointIndex < m_pointCount; firstPointIndex++)
		{
			if (m_pointList[firstPointIndex] == firstPoint)
			{
				break;
			}
		}
		if (firstPointIndex == m_pointCount)
		{
			return false;
		}

		int secondPointIndex = 0;
		for (; secondPointIndex < m_pointCount; secondPointIndex++)
		{
			if (m_pointList[secondPointIndex] == secondePoint)
			{
				break;
			}
		}
		if (secondPointIndex == m_pointCount)
		{
			return false;
		}

		m_collarMatrix[firstPointIndex][secondPointIndex] = edgeValue;
		m_collarMatrix[secondPointIndex][firstPointIndex] = edgeValue;

		return true;
	}

	bool setEdge(_PointType firstPoint, _PointType secondePoint, _EdgeDataType edgeValue)
	{
		if (edgeValue == _EdgeDataType())
		{
			return false;
		}

		int firstPointIndex = 0;
		for (; firstPointIndex < m_pointCount; firstPointIndex++)
		{
			if (m_pointList[firstPointIndex] == firstPoint)
			{
				break;
			}
		}
		if (firstPointIndex == m_pointCount)
		{
			return false;
		}

		int secondPointIndex = 0;
		for (; secondPointIndex < m_pointCount; secondPointIndex++)
		{
			if (m_pointList[secondPointIndex] == secondePoint)
			{
				break;
			}
		}
		if (secondPointIndex == m_pointCount)
		{
			return false;
		}

		m_collarMatrix[firstPointIndex][secondPointIndex] = edgeValue;
		m_collarMatrix[secondPointIndex][firstPointIndex] = edgeValue;

		return true;
	}

	bool removeEdge(_PointType firstPoint, _PointType secondePoint)
	{
		int firstPointIndex = 0;
		for (; firstPointIndex < m_pointCount; firstPointIndex++)
		{
			if (m_pointList[firstPointIndex] == firstPoint)
			{
				break;
			}
		}
		if (firstPointIndex == m_pointCount)
		{
			return false;
		}

		int secondPointIndex = 0;
		for (; secondPointIndex < m_pointCount; secondPointIndex++)
		{
			if (m_pointList[secondPointIndex] == secondePoint)
			{
				break;
			}
		}
		if (secondPointIndex == m_pointCount)
		{
			return false;
		}

		m_collarMatrix[firstPointIndex][secondPointIndex] = _EdgeDataType();
		m_collarMatrix[secondPointIndex][firstPointIndex] = _EdgeDataType();

		return true;
	}

	void printPoint() const
	{
		if (m_pointCount == 0)
		{
			return;
		}

		std::cout << "[";
		for (int j = 0; j < m_pointCount - 1; j++)
		{
			std::cout << m_pointList[j] << ", ";
		}
		std::cout << m_pointList[m_pointCount - 1] << "]" << std::endl;
	}

	void printGraph() const
	{
		for (int i = 0; i < m_pointCount; i++)
		{
			std::cout << "[";
			for (int j = 0; j < m_pointCount - 1; j++)
			{
				std::cout << m_collarMatrix[i][j] << ", ";
			}
			std::cout << m_collarMatrix[i][m_pointCount - 1] << "]" << std::endl;
		}
	}

	void DFS()
	{
		if (m_pointCount <= 0)
		{
			return;
		}

		bool* isVisit = new bool[m_pointCount];
		for (int i = 0; i < m_pointCount; i++)
		{
			isVisit[i] = false;
		}

		for (int i = 0; i < m_pointCount; i++)
		{
			if (!isVisit[i])
			{
				DFS(m_collarMatrix, i, isVisit);
			}
		}
		
		delete[]isVisit;
	}

	void BFS() {
		if (m_pointCount <= 0)
		{
			return;
		}

		bool* isVisit = new bool[m_pointCount];
		for (int i = 0; i < m_pointCount; i++)
		{
			isVisit[i] = false;
		}

		std::queue<int> pointQueue;
		for (int currentPointIndex = 0; currentPointIndex < m_pointCount; currentPointIndex++) {
			if (!isVisit[currentPointIndex]) {
				isVisit[currentPointIndex] = true;
				std::cout << m_pointList[currentPointIndex] << ", ";

				pointQueue.push(currentPointIndex);

				while (!pointQueue.empty()) {
					int currentIndex = pointQueue.front();
					pointQueue.pop();

					for (int j = 0; j < m_pointCount;j++) {
						if (m_collarMatrix[currentIndex][j] != _EdgeDataType() && !isVisit[j]) {
							std::cout << m_pointList[j] << ", ";
							isVisit[j] = true;
							pointQueue.push(j);
						}
					}
				}
			}
		}
	}

protected:
	void DFS(_EdgeDataType** collarMatrix, int currentPointIndex, bool* isVisit)
	{
		isVisit[currentPointIndex] = true;
		std::cout << m_pointList[currentPointIndex] << ", ";
		for (int j = 0; j < m_pointCount; j++)
		{
			if (collarMatrix[currentPointIndex][j] != _EdgeDataType() && !isVisit[j])
			{
				DFS(collarMatrix, j, isVisit);
			}
		}
	}

	void clear()
	{
		if (m_pointList != nullptr)
		{
			delete[]m_pointList;
			m_pointList = nullptr;
		}

		if (m_collarMatrix != nullptr)
		{
			for (int i = 0; i < m_pointCount; i++)
			{
				delete[]m_collarMatrix[i];
				m_collarMatrix[i] = nullptr;
			}

			delete[]m_collarMatrix;
			m_collarMatrix = nullptr;
		}

		m_pointCount = 0;
	}

private:
	_PointType* m_pointList;
	_EdgeDataType** m_collarMatrix;
	int m_pointCount;
};

#endif // !_GRAPH_H_

5.总结

上面只是一种实现方式，往后再写其他的实现方式。

大唐不良猿
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【2025王道数据结构】王道数据结构课后代码题汇总答案C、C++代码实现完整版大全（可直接运行）
CSDN 精品推荐
04-25 1万+
下面内容是本人在复习王道数据结构的过程中, 对一些算法设计题目的全部实现（答案解析全部都是伪码或者函数的部分实现，不可调试运行），不一定是最优的, 但是都能保证端到端测试运行，本文会陆陆续续更新，个人水平有限，可能文章里面存在一些问题，还望各位多多指点。   加油，阿光！！！我看好你哦😋😋😋 以下摘自王道2023年数据结构考研复习指导题目 文章目录 😉第2章：线性表 ✌18页综合应用题 题号 题解链接 1 传送门 2 传送门 3 传送门 4 传送门 5 传送.
数据结构和算法 python和c++语言描述_数据结构和算法 Python和C++语言描述
weixin_42551260的博客
02-12 673
本书使用Python 和C++两种编程语言来介绍数据结构。全书内容共15 章。书中首先介绍了抽象与分析、数据的抽象等数据结构的基本原理和知识，然后结合Python 的特点介绍了容器类、链式结构和迭代器、堆栈和队列、递归、树；随后，简单介绍了C++语言的知识，并进一步讲解了C++类、C++的动态内存、C++的链式结构、C++模板、堆、平衡树和散列表、图等内容；最后对算法技术进行了总结。每章最后给出了...
c++数据结构：图
sylviiiiiia的博客
11-13 494
图的ADT定义 G = (Vertx顶点, Edge边（无向）、弧（单向，有弧头，弧尾）) 多对多 邻接 a->f则f是a的邻接点，反之不成立 出度、入度 有向图、无向图 边 稀疏图、稠密图 边少or边多 极致的稠密图是完全图 带权图 子图G’=(V’, E’) 路径P=(v0v1…vn-1) 回路R=(v0v1…vn-1v0)邻接矩阵/邻接表是顺序表 o(n2) 包含结点数目，结点名称，邻接矩阵是链表，使用前插法o(1)，适合于存储稀疏图o(e)，e是边数，完全图e=n2而且还占用空间更多 包含边（权重
C++——数据结构
摸鱼中......
03-11 5725
前言 线性表（有序表）分为数组描述的线性表和链式描述的线性表。 数组和矩阵。 栈和队列。 跳表和散列。 二叉树和其他树。 优先级队列。 竞赛树和搜索树。 平衡搜索树。 图。 一、线性表——数组描述 （1）数组类型（通过模板类解决）和数组长度（动态数组解决）。 （2）动态数组，可以使用一个变量（非const值）从键盘上获取数组的长度： int n; printf("请输入数组的长度："); scanf("%d",&n); int sz[n];//动态数组 （3）没有实现代码的成员函数称为纯虚函数；
《算法和数据结构》题海战术篇
热门推荐
英雄哪里出来
09-12 5万+
刷了 3333 题 算法题 后的一点点经验总结 —— 题不是这么刷的！
数据结构课设——稀疏矩阵的操作
肉夹馍的博客
10-01 307
数据结构的课程设计，以前写的
数据结构与算法 c++描述 目录与源码
比卡丘不皮的博客
08-03 2339
时间过的很快，数据结构部分写到了一定的文章了，后面的部分我会慢慢更新，这里记录了当前一个小节点。 本人使用的是vs2015，对应的书是《数据结构与算法 c++描述 第三版》 本人把自己写的代码，都写在了一个工程里面，方便记录与查找如下图： 代码上传到git 仓库：码云仓库 没有码云的小伙伴我上传到了我的百度云盘：链接：云盘连接提取码：36al 有了代码可以看对应的博客链接： 数据结构c++描述（一）---线性表数组表达 https://blog.csdn.net/weixin_421...
C/C++数据结构练习题[2023-05-08]
code helper
05-08 9787
目的：字符串是一种基础且广泛使用的数据结构，与字符串相关的题目既可 以考察基本程序设计能力和技巧，也可以考查算法设计能力。 题目：求字符串之间距离 要求：设有字符串 X，称在 X 的头尾及中间插入任意多个空格后构成的新 字符串为 X 的扩展串，如字符串 X 为“abcbcd”，则字符串“abcb□cd”，“□a□bcbcd□” 和“abcb□cd□”都是 X 的扩展串，这里“□”代表空格字符。如果 A1 是字符串 A 的 扩展串，B1 是字符串 B 的扩展串，A1 与 B1 具有相同的长度，那么定义字符串
C/C++数据结构课程设计[2023-06-15]
code helper
06-15 347
课程设计指导书学院 信息工程学院专业 人工智能课程 数据结构课程设计班级 22智能1班指 导 教 师 康子洋2022 — 2023 学年度第 二 学期一、数据结构课程设计的目的数据结构课程设计是一项综合性设计活动，要求在教师的指导下，利用本课程内的以及到目前为止所学到的有关知识和技术解决一些不太复杂但却是综合性的问题。从规模来说，课程设计是在平时作业的基础上进一步扩大的大作业。在设计中，要求学生要全面考虑相互联系的各个方面及问题。
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
2.4.3 三种基本结构和改进的流程图 28 2.4.4 用N-S 流程图表示算法 29 2.4.5 用伪代码表示算法 30 2.4.6 用计算机语言表示算法 31 2.5 结构化程序设计方法 31 3 数据类型、运算符与表达式 3.1 Ｃ语言的数据类型 32 ...
数据结构算法与应用-C++语言描述
10-20
讲述了c++的各种使用的数据结构和算法，对于初学者和已经入门的都很有帮助，里面的内容有 目 录 译者序 前言 第一部分 预备知识 第1章 C++程序设计 1 1.1 引言 1 1.2 函数与参数 2 1.2.1 传值参数 2 1.2.2 模板函数 ...
数据结构算法与应用-C C++语言描述
11-19
第二部分 数据结构 第3章 数据描述 75 3.1 引言 75 3.2 线性表 76 3.3 公式化描述 77 3.3.1 基本概念 77 3.3.2 异常类NoMem 79 3.3.3 操作 79 3.3.4 评价 83 3.4 链表描述 86 3.4.1 类ChainNode 和Chain 86 3.4.2 ...
数据结构逻辑
qq_42129915的博客
06-10 265
1、线性关系2：树型关系3：图像关系。
【数据结构】 -- 堆 （堆排序）（TOP-K问题）
prettyxian的博客
06-09 1015
要学习堆，首先要先简单的了解一下二叉树，二叉树是一种常见的树形数据结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的应用非常广泛，在后面我会详细介绍。满二叉树：除了叶子结点外，每个结点都有两个子结点一个深度为k的满二叉树有2的k次方减一个节点。完全二叉树：除了最底层可能不是满的外，其它每一层从左到右都是满的。满二叉树是完全二叉树的子集，满二叉树一定是完全二叉树，但完全二叉树不一定是满二叉树。堆就是一种完全二叉树。
【算法】常用排序算法（插入排序、希尔排序、堆排序、选择排序、冒泡排序、快速排序、归并排序、计数排序）超详细
abcwyffff的博客
06-09 960
排序算法是数据结构相关知识中非常重要的一节，相信很多小伙伴对这部分知识一知半解。那么接下来，小编就要带领大家一起来进行对排序算法的深入剖析学习，希望本篇文章能够使你有所收获！
如何使用Python中的collections模块提供的数据结构，如deque、Counter、OrderedDict等
2402_84885073的博客
06-09 355
Python 的模块提供了一些额外的数据结构，这些数据结构在内置的数据类型（如列表、字典、集合等）的基础上，增加了额外的功能或优化了性能。下面是如何使用模块中的dequeCounter和这三种数据结构的简单示例。
数据结构-二叉树
最新发布
passworddddddd的博客
06-12 157
树（Tree）是一种非常重要的数据结构，它模拟了一种层级或者分支结构。在树结构中，数据以节点（Node）的形式存储，并且每个节点都可以有零个或多个子节点。除了二叉树最后一层，其他各层的节点数都达到最大个数，且最后一层从左向右的叶节点连续存在，只缺右侧若干节点。完美二叉树是特殊的完全二叉树。除了最下一层的叶子节点外，每层节点都有两个子节点，就构成了满二叉树。如果树中每个节点最多只能有两个子节点，这样的树就称之为二叉树。
C语言刷题（函数）
2303_82176667的博客
06-09 659
一个数如果恰好等于它的所有因子(不包括它本身)之和，这个数就称为“完数”。
c++创建有向图，领接矩阵方法
05-11
要创建一个有向图并使用邻接矩阵表示，需要以下几个步骤： 1. 定义图的大小：图的大小指的是图中节点的数量。您可以使用一个整数n来表示。 2. 创建邻接矩阵：邻接矩阵是一个n x n的矩阵，其中每个元素代表节点间的连通性。如果节点i到节点j有一条有向边，则矩阵中第i行第j列的元素为1。否则，该元素为0。 3. 初始化邻接矩阵：将邻接矩阵中所有元素初始化为0。 4. 添加边：对于每个有向边(i, j)，将邻接矩阵中第i行第j列的元素设置为1。 下面是一个使用C++实现邻接矩阵的有向图的示例代码： ```c++ #include <iostream> using namespace std; const int MAXN = 100; // 定义图的最大节点数 int n; // 图的节点数量 int graph[MAXN][MAXN]; // 邻接矩阵 int main() { // 输入节点数量 cout << "请输入节点数量："; cin >> n; // 初始化邻接矩阵 for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { graph[i][j] = 0; } } // 添加边 int m; // 边的数量 cout << "请输入边的数量："; cin >> m; cout << "请输入每条边的起点和终点（用空格分隔）：" << endl; for (int i = 0; i < m; i++) { int u, v; // 边的起点和终点 cin >> u >> v; graph[u][v] = 1; } // 输出邻接矩阵 cout << "邻接矩阵为：" << endl; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { cout << graph[i][j] << " "; } cout << endl; } return 0; } ``` 这段代码可以让用户输入节点数量和边的数量，并根据用户输入构建有向图的邻接矩阵，并将其输出到屏幕上。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

大唐不良猿

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

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

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

打赏作者

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

抵扣说明：

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

余额充值