图的三种表示方法

最新推荐文章于 2024-07-02 16:37:54 发布
最新推荐文章于 2024-07-02 16:37:54 发布
阅读量3k 收藏 6
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zwz2011303359/article/details/63253735
版权
图的表示最长用的两种方法是：

1）、邻接矩阵表示法

2）、邻接表表示


下面是两种构造图的方法

1）邻接矩阵：

[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. #include <iostream>  
  2. #include <vector>  
  3. using namespace std;  
  4.   
  5. //枚举类型，图的种类 DG：有向图；WDG：带权值的有向图；  
  6. //UDG: 无向图；WUDG: 带权值的无向图  
  7. enum GraphKind {DG, WDG, UDG, WUDG};  
    1. //枚举类型，图的种类 DG：有向图；WDG：带权值的有向图；  
    2. //UDG: 无向图；WUDG: 带权值的无向图  
  8.   
  9. //vertexType顶点类型，VRType：顶点之间的关系类型，InfoType：弧的信息类型  
  10. template <typename VertexType, typename VRType, typename InfoType>  
  11. class MGraph  
  12. {  
  13. public:  
  14.     MGraph(int vexNum, GraphKind __kind) : vexnum(vexNum), arcnum(0), kind(__kind)  
  15.     {  
  16.         //分配顶点向量数组  
  17.         vvec = new VertexType[vexnum];  
  18.         //动态分配二维数组， 注意二维数组的动态分配  
  19.         arcs = new ArcCell *[vexnum];  
  20.         for (int i = 0; i < vexnum; i++)  
  21.         {  
  22.             //为每一行动态分配空间  
  23.             arcs[i] = new ArcCell[vexnum];  
  24.         }  
  25.     }  
  26.   
  27.     void Create()  
  28.     {  
  29.         switch (kind)  
  30.         {  
  31.         case DG:   
  32.             {  
  33.                 CreateDG();    //构造一个有向图  
  34.                 break;  
  35.             }             
  36.         case WDG:  
  37.             {  
  38.                 CreateWDG();    //构造一个带权有向图  
  39.                 break;  
  40.             }  
  41.         case UDG:  
  42.             {  
  43.                 CreateUDG();    //构造一个无向图  
  44.                 break;  
  45.             }  
  46.         case WUDG:  
  47.             {   
  48.                 CreateWUDG();   //构造一个带权无向图  
  49.                 break;  
  50.             }  
  51.         default:  
  52.             return;  
  53.         }  
  54.     }  
  55.   
  56.     //初始化顶点数组和邻接矩阵  
  57.     void Init()  
  58.     {  
  59.         cout << "请输入每个顶点的关键字：" << endl;  
  60.         VertexType val;  
  61.         for (int i = 0; i < vexnum; i++)  
  62.         {  
  63.             cin >> val;  
  64.             vvec[i] = val;  
  65.         }  
  66.         for (int i = 0; i < vexnum; i++)  
  67.         {  
  68.             ArcCell ac;  
  69.             ac.adj = 0;  
  70.             ac.info = NULL;  
  71.             for (int j = 0; j < vexnum; j++)  
  72.             {             
  73.                 arcs[i][j] = ac;  
  74.             }  
  75.         }  
  76.     }  
  77.   
  78.     //构造一个有向图  
  79.     void CreateDG()  
  80.     {  
  81.         Init();  
  82.         int vhead, vtail;  
  83.         cout << "请依次输入每条边的开始顶点和结束顶点：" << endl;  
  84.         while (cin >> vhead >> vtail)  
  85.         {  
  86.             arcnum++;  
  87.             arcs[vhead][vtail].adj = 1;  
  88.         }  
  89.     }  
  90.   
  91.     //构造一个带权有向图  
  92.     void CreateWDG()  
  93.     {  
  94.         Init();  
  95.         int vhead, vtail;  
  96.         InfoType w;  
  97.         cout << "请依次输入每条边的开始顶点和结束顶点和权值：" << endl;  
  98.         while (cin >> vhead >> vtail >> w)  
  99.         {  
  100.             arcnum++;  
  101.             arcs[vhead][vtail].adj = w;  
  102.         }  
  103.     }  
  104.   
  105.     //构造一个无向图  
  106.     void CreateUDG()  
  107.     {  
  108.         Init();  
  109.         int vhead, vtail;  
  110.         cout << "请依次输入每条边的开始顶点和结束顶点：" << endl;  
  111.         while (cin >> vhead >> vtail)  
  112.         {  
  113.             arcnum += 2;  
  114.             arcs[vhead][vtail].adj  = 1;  
  115.             arcs[vtail][vhead].adj  = 1;  
  116.         }  
  117.     }  
  118.   
  119.     //构造一个带权无向图  
  120.     void CreateWUDG()  
  121.     {  
  122.         Init();  
  123.         int vhead, vtail;  
  124.         InfoType w;  
  125.         cout << "请依次输入每条边的开始顶点和结束顶点和权值：" << endl;  
  126.         while (cin >> vhead >> vtail >> w)  
  127.         {  
  128.             arcnum += 2;  
  129.             arcs[vhead][vtail].adj = w;  
  130.             arcs[vtail][vhead].adj = w;  
  131.         }  
  132.     }  
  133.   
  134.     void displayGraph()  
  135.     {  
  136.         cout << "总共有" << vexnum << "个顶点，"   
  137.              << arcnum << "条边" << endl;  
  138.         for (int i = 0; i < vexnum; i++)  
  139.         {  
  140.             cout << "第" << i+1 << "个顶点是：" << vvec[i]   
  141.                  << "相邻的边有: ";  
  142.             for (int j = 0; j < vexnum; j++)  
  143.             {  
  144.                 if (arcs[i][j].adj != 0)  
  145.                     cout << vvec[j] << "(" << arcs[i][j].adj << ") ";   
  146.             }  
  147.             cout << endl;  
  148.         }  
  149.     }  
  150.   
  151. private:  
  152.     struct ArcCell  
  153.     {  
  154.         VRType adj;   //顶点关系类型。对于无权图，用1或0表示  
  155.                       //表示相邻与否；对带权图，为权值类型  
  156.         InfoType info;  //该弧相关的信息的指针  
  157.     };  
  158.     VertexType *vvec;          //顶点向量  
  159.     ArcCell **arcs;    //邻接矩阵  
  160.     int vexnum;                       //图的当前顶点个数  
  161.     int arcnum;                       //图的弧数  
  162.     GraphKind kind;                   //图的种类标志  
  163. };  
  164.   
  165. int main()  
  166. {  
  167.     cout << "构造无向图：" << endl;  
  168.     MGraph<char, int, int> udgGraph(8, UDG);  
  169.     udgGraph.Create();  
  170.     udgGraph.displayGraph();  
  171.   
  172.     cout << "构造带权无向图：" << endl;  
  173.     MGraph<char, int, int> wudgGraph(9, WUDG);  
  174.     wudgGraph.Create();  
  175.     wudgGraph.displayGraph();  
  176.   
  177.     cout << "构造有向图：" << endl;  
  178.     MGraph<char, int, int> dgGraph(6, DG);  
  179.     udgGraph.Create();  
  180.     udgGraph.displayGraph();  
  181.   
  182.     cout << "构造带权有向图：" << endl;  
  183.     MGraph<char, int, int> wdgGraph(6, WDG);  
  184.     wdgGraph.Create();  
  185.     wdgGraph.displayGraph();  
  186.   
  187.     system("pause");  
  188.     return 0;  
  189. }  
#include <iostream>
#include <vector>
using namespace std;

//枚举类型，图的种类 DG：有向图；WDG：带权值的有向图；
//UDG: 无向图；WUDG: 带权值的无向图
enum GraphKind {DG, WDG, UDG, WUDG};

//vertexType顶点类型，VRType：顶点之间的关系类型，InfoType：弧的信息类型
template <typename VertexType, typename VRType, typename InfoType>
class MGraph
{
public:
	MGraph(int vexNum, GraphKind __kind) : vexnum(vexNum), arcnum(0), kind(__kind)
	{
		//分配顶点向量数组
        vvec = new VertexType[vexnum];
		//动态分配二维数组， 注意二维数组的动态分配
        arcs = new ArcCell *[vexnum];
		for (int i = 0; i < vexnum; i++)
		{
			//为每一行动态分配空间
			arcs[i] = new ArcCell[vexnum];
		}
	}

	void Create()
	{
		switch (kind)
		{
		case DG: 
			{
				CreateDG();    //构造一个有向图
				break;
			}			
		case WDG:
			{
				CreateWDG();    //构造一个带权有向图
				break;
			}
		case UDG:
			{
				CreateUDG();    //构造一个无向图
				break;
			}
		case WUDG:
			{ 
				CreateWUDG();   //构造一个带权无向图
				break;
			}
		default:
			return;
		}
	}

	//初始化顶点数组和邻接矩阵
	void Init()
	{
		cout << "请输入每个顶点的关键字：" << endl;
		VertexType val;
		for (int i = 0; i < vexnum; i++)
		{
			cin >> val;
			vvec[i] = val;
		}
		for (int i = 0; i < vexnum; i++)
		{
			ArcCell ac;
			ac.adj = 0;
			ac.info = NULL;
			for (int j = 0; j < vexnum; j++)
			{			
                arcs[i][j] = ac;
			}
		}
	}

	//构造一个有向图
	void CreateDG()
	{
		Init();
		int vhead, vtail;
		cout << "请依次输入每条边的开始顶点和结束顶点：" << endl;
		while (cin >> vhead >> vtail)
		{
			arcnum++;
			arcs[vhead][vtail].adj = 1;
		}
	}

	//构造一个带权有向图
	void CreateWDG()
	{
		Init();
		int vhead, vtail;
		InfoType w;
		cout << "请依次输入每条边的开始顶点和结束顶点和权值：" << endl;
		while (cin >> vhead >> vtail >> w)
		{
			arcnum++;
			arcs[vhead][vtail].adj = w;
		}
	}

	//构造一个无向图
	void CreateUDG()
	{
		Init();
		int vhead, vtail;
		cout << "请依次输入每条边的开始顶点和结束顶点：" << endl;
		while (cin >> vhead >> vtail)
		{
			arcnum += 2;
			arcs[vhead][vtail].adj  = 1;
			arcs[vtail][vhead].adj  = 1;
		}
	}

	//构造一个带权无向图
	void CreateWUDG()
	{
		Init();
		int vhead, vtail;
		InfoType w;
		cout << "请依次输入每条边的开始顶点和结束顶点和权值：" << endl;
		while (cin >> vhead >> vtail >> w)
		{
			arcnum += 2;
			arcs[vhead][vtail].adj = w;
			arcs[vtail][vhead].adj = w;
		}
	}

	void displayGraph()
	{
		cout << "总共有" << vexnum << "个顶点，" 
			 << arcnum << "条边" << endl;
		for (int i = 0; i < vexnum; i++)
		{
			cout << "第" << i+1 << "个顶点是：" << vvec[i] 
			     << "相邻的边有: ";
		    for (int j = 0; j < vexnum; j++)
		    {
				if (arcs[i][j].adj != 0)
					cout << vvec[j] << "(" << arcs[i][j].adj << ") "; 
		    }
			cout << endl;
		}
	}

private:
    struct ArcCell
	{
		VRType adj;   //顶点关系类型。对于无权图，用1或0表示
		              //表示相邻与否；对带权图，为权值类型
		InfoType info;  //该弧相关的信息的指针
	};
	VertexType *vvec;          //顶点向量
	ArcCell **arcs;    //邻接矩阵
	int vexnum;                       //图的当前顶点个数
	int arcnum;                       //图的弧数
    GraphKind kind;                   //图的种类标志
};

int main()
{
	cout << "构造无向图：" << endl;
	MGraph<char, int, int> udgGraph(8, UDG);
	udgGraph.Create();
	udgGraph.displayGraph();

	cout << "构造带权无向图：" << endl;
	MGraph<char, int, int> wudgGraph(9, WUDG);
	wudgGraph.Create();
	wudgGraph.displayGraph();

	cout << "构造有向图：" << endl;
	MGraph<char, int, int> dgGraph(6, DG);
	udgGraph.Create();
	udgGraph.displayGraph();

	cout << "构造带权有向图：" << endl;
	MGraph<char, int, int> wdgGraph(6, WDG);
	wdgGraph.Create();
	wdgGraph.displayGraph();

	system("pause");
	return 0;
}


运行了一个带权有向图：



2）邻接链表

[cpp] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. //枚举类型，图的种类 DG：有向图；WDG：带权值的有向图；  
  5. //UDG: 无向图；WUDG: 带权值的无向图  
  6. enum GraphKind {DG, WDG, UDG, WUDG};  
  7.   
  8. template<typename VertexType, typename InfoType>  
  9. class ALGraph  
  10. {  
  11. public:  
  12.     ALGraph(int verNum, GraphKind _kind)   
  13.         : vexnum(verNum), arcnum(0), kind(_kind)    
  14.     {  
  15.         for (int i = 0; i < MAX_VERTEX_NUM; i++)  
  16.             vertices[i].firstarc = NULL;  
  17.     }  
  18.   
  19.     //构造图，进行选择  
  20.     void Create()  
  21.     {  
  22.         switch (kind)  
  23.         {  
  24.         case DG:   
  25.             {  
  26.                 CreateDG();    //构造一个有向图  
  27.                 break;  
  28.             }             
  29.         case WDG:  
  30.             {  
  31.                 CreateWDG();    //构造一个带权有向图  
  32.                 break;  
  33.             }  
  34.         case UDG:  
  35.             {  
  36.                 CreateUDG();    //构造一个无向图  
  37.                 break;  
  38.             }  
  39.         case WUDG:  
  40.             {   
  41.                 CreateWUDG();   //构造一个带权无向图  
  42.                 break;  
  43.             }  
  44.         default:  
  45.             return;  
  46.         }  
  47.     }  
  48.       
  49.     //打印邻接链表  
  50.     void displayGraph()  
  51.     {  
  52.         for (int i = 0; i < vexnum; i++)  
  53.         {  
  54.             cout << "第" << i+1 << "个顶点是：" << vertices[i].data  
  55.                 << " 邻接表为: ";  
  56.             ArcNode *arcNode = vertices[i].firstarc;  
  57.             while (arcNode != NULL)  
  58.             {  
  59.                 cout << " -> " << vertices[arcNode->adjvex].data  
  60.                     << "(" << arcNode->info << ")";  
  61.                 arcNode = arcNode->nextarc;  
  62.             }  
  63.             cout << endl;  
  64.         }  
  65.     }  
  66.   
  67. private:  
  68.     //初始化邻接链表的表头数组  
  69.     void InitVertics()  
  70.     {  
  71.         cout << "请输入每个顶点的关键字：" << endl;  
  72.         VertexType val;  
  73.         for (int i = 0; i < vexnum; i++)  
  74.         {  
  75.             cin >> val;  
  76.             vertices[i].data = val;  
  77.         }  
  78.     }  
  79.   
  80.     //插入一个表结点  
  81.     void insertArc(int vHead, int vTail, InfoType w)  
  82.     {  
  83.         //构造一个表结点  
  84.         ArcNode *newArcNode = new ArcNode;  
  85.         newArcNode->adjvex = vTail;  
  86.         newArcNode->nextarc = NULL;  
  87.         newArcNode->info = w;  
  88.   
  89.         //arcNode 是vertics[vHead]的邻接表  
  90.         ArcNode *arcNode = vertices[vHead].firstarc;  
  91.         if (arcNode == NULL)  
  92.             vertices[vHead].firstarc = newArcNode;  
  93.         else  
  94.         {  
  95.             while (arcNode->nextarc != NULL)  
  96.             {  
  97.                 arcNode = arcNode->nextarc;        
  98.             }  
  99.             arcNode->nextarc = newArcNode;  
  100.         }  
  101.         arcnum++;  
  102.     }  
  103.   
  104.     //构造一个有向图  
  105.     void CreateDG()  
  106.     {  
  107.         InitVertics();  
  108.         int vhead, vtail;  
  109.         cout << "请依次输入每条边的开始顶点和结束顶点：" << endl;  
  110.         while (cin >> vhead >> vtail)  
  111.         {  
  112.             insertArc(vhead, vtail, 0);  
  113.         }  
  114.     }  
  115.   
  116.     //构造一个带权有向图  
  117.     void CreateWDG()  
  118.     {  
  119.         InitVertics();  
  120.         int vhead, vtail;  
  121.         InfoType w;  
  122.         cout << "请依次输入每条边的开始顶点和结束顶点和权值：" << endl;  
  123.         while (cin >> vhead >> vtail >> w)  
  124.         {  
  125.             insertArc(vhead, vtail, w);  
  126.         }  
  127.     }  
  128.   
  129.     //构造一个无向图  
  130.     void CreateUDG()  
  131.     {  
  132.         InitVertics();  
  133.         int vhead, vtail;  
  134.         cout << "请依次输入每条边的开始顶点和结束顶点：" << endl;  
  135.         while (cin >> vhead >> vtail)  
  136.         {  
  137.             insertArc(vhead, vtail, 0);  
  138.             insertArc(vtail, vhead, 0);  
  139.         }  
  140.     }  
  141.   
  142.     //构造一个带权无向图  
  143.     void CreateWUDG()  
  144.     {  
  145.         InitVertics();  
  146.         int vhead, vtail;  
  147.         InfoType w;  
  148.         cout << "请依次输入每条边的开始顶点和结束顶点和权值：" << endl;  
  149.         while (cin >> vhead >> vtail >> w)  
  150.         {  
  151.             insertArc(vhead, vtail, w);  
  152.             insertArc(vtail, vhead, w);  
  153.         }  
  154.     }  
  155.   
  156.   
  157.     //const数据成员必须在构造函数里初始化  
  158.     static const int MAX_VERTEX_NUM = 20;  //最大顶点个数  
  159.   
  160.   
  161.     struct ArcNode          //表结点  
  162.     {  
  163.         int adjvex;        //该弧所指向的顶点的位置  
  164.         ArcNode *nextarc;  //指向下一条弧的指针  
  165.         InfoType info;     //该弧相关信息的指针  
  166.     };  
  167.     struct VNode           //头结点  
  168.     {  
  169.         VertexType data;    //顶点信息  
  170.         ArcNode *firstarc;  //指向第一条依附于该顶点的弧的指针  
  171.     };  
  172.   
  173.     /*VNode AdjList[MAX_VERTEX_NUM];*/   
  174.     /* AdjList[MAX_VERTEX_NUM] vertices;*/  
  175.     VNode vertices[MAX_VERTEX_NUM];  
  176.     int vexnum;             //图的当前顶点数  
  177.     int arcnum;             //图的弧数  
  178.     GraphKind kind;         //图的种类   
  179. };  
  180.   
  181. int main()  
  182. {  
  183.     cout << "构造一个8个顶点的无向图:" << endl;  
  184.     ALGraph<char, int> udgGraph(8, UDG);  
  185.     udgGraph.Create();  
  186.     udgGraph.displayGraph();  
  187.   
  188.     cout << "构造一个9个顶点的带权无向图:" << endl;  
  189.     ALGraph<char, int> wudgGraph(9, WUDG);  
  190.     wudgGraph.Create();  
  191.     wudgGraph.displayGraph();  
  192.   
  193.     cout << "构造一个6个顶点的有向图:" << endl;  
  194.     ALGraph<char, int> dgGraph(6, DG);  
  195.     dgGraph.Create();  
  196.     dgGraph.displayGraph();  
  197.   
  198.     cout << "构造一个9个顶点的带权有向图:" << endl;  
  199.     ALGraph<char, int> wdgGraph(9, WDG);  
  200.     wdgGraph.Create();  
  201.     wdgGraph.displayGraph();  
  202.   
  203.     system("pause");  
  204.     return 0;  
  205. }  

zwz2011303359
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【图论】图的表示方法
zsjzliziyang的博客
08-24 2796
图的表示 对于一张图G=（V，E）G=（V，E）G=（V，E），可以用两种标准的表示方法表示。一种是将图作为邻接链表的组合，另一种则是将图作为邻接矩阵来看待两种表示方法都可以表示无向图和无向图。当图为稀疏图时（边的条数|E||E||E|远远小于点的数量|V|2|V|2|V|^2的图）时通常采用邻接链表，如此节省空间开销。反之，当图为稠密图（|E||E||E|接近|V|2|V|2|V|^2的图）的...
简单好理解的图论讲解（图论的三种表现形式以及相关操作）
weixin_55469859的博客
08-28 2099
图论是数据结构与算法中必须逾越的一座大山，适用范围非常广泛，当然也具有一定的难度，本人也是今年第一次学习图论的知识点，不能说掌握的很好，但我会尽可能的把我学会的知识点分享给大家，在写这篇博客之前我也查阅了很多大牛的图论分享，也算基本上涵盖了图论的重要知识点，如有错误还望各路大神斧正。另外以下程序都是由C语言编写的，海域。 首先我们简单认识一下图论，我举一个最简单的例子，就是我们常用的百度或者高德地图，我们在导航时，背后的本质就是图论的各种算法，例如是否有通路可以抵达，或者最...
数据结构 —— 图的表示
最新发布
qq_67693066的博客
07-02 743
数据结构 —— 图的表示
表示图的三种方法
weixin_30751947的博客
02-13 853
（原址） 三标准： 图结构占用的空间 确定图的一条给定边界花费的时间 从给定节点处找到邻居花费的时间 Edge List 以[v,w]为元素的列表，其中v，w为节点编号，每个元素表示一条边； 如果有权重，则元素形式为[v,w,k] 缺点：搜索某一特定边缘，必须进行遍历，最坏情况需要遍历完整个列表（不满足标准2） 表示方法： ```[ [0,1], [0,6], [0,8], [1,4],...
图的几种表示方法
qq_32439305的博客
09-08 2958
图的几种表示方法 1.邻接矩阵表示法 如图： 也就是说，如果两节点之间有一条弧，则邻接矩阵中对应的元素为1；否则为0。可以看出，这种表示法非常简单、直接。但是，在邻接矩阵的所有元素中，只有少量为非零元。如果网络比较稀疏，这种表示法浪费大量的存储空间，从而增加了在网络中查找弧的时间。 同样，对于网络中的权，也可以用类似邻接矩阵的 矩阵表示。只是此时一条弧所对应的元素不再是1，而是相应的权而已。如果网络中每条弧赋有多种权，则可以用多个矩阵表示这些权。 2. 关联矩阵表示法 也就是说，在关联矩阵中，每行对应于
图的常用表示方法
qq_44932835的博客
04-07 709
图的常用表示方法
图的表示方法
qhu1600417010的博客
05-09 719
图的表示方法1. 左神课程给出的图结构模板 图的常见表示方法是邻接表和邻接矩阵，但是没了应对题目的千变万化和降低考试的时候的错误率，可以自己写一种自己熟悉的图结构，然后再遇到图算法的题目的时候，只需要写一个转化函数将题目给的图结构转换为自己定义的图结构就行 1. 左神课程给出的图结构模板 左神语录：不带模板上考场，就等于裸奔 构建思路 a） 图的大结构 class Graph { } ...
python 邻接矩阵三种方法实现有向图、无向图，并绘图显示
11-12
在Python编程中，邻接矩阵是一种常见的数据结构，用于表示图的结构，无论是有向图还是无向图。本文将详细介绍如何使用邻接矩阵来实现这两种类型的图，并通过`NetworkX`库进行可视化显示。 首先，让我们理解邻接矩阵...
彩色图像灰度化的三种方法
05-29
本篇将详细介绍三种常用的彩色图像灰度化方法：直方图均衡化、亮度平均值法和加权平均法。 1. 直方图均衡化 直方图均衡化是通过改变图像的灰度级分布，使整个图像的灰度级分布更加均匀，从而增强图像的对比度。它的...
三种配色的扁平化PPT甘特图
07-16
【标题】：“三种配色的扁平化PPT甘特图” 在现代的演示文稿设计中，甘特图是一种非常实用的工具，用于清晰地展示项目的时间线、任务进度和资源分配。扁平化设计则让这些图表更加简洁、时尚，更符合现代审美。本...
城市三维仿真地图的二维表达方法应用研究
05-27
文中结合实际工作对传统制图表达方法进行的一种创新和尝试,将传统街区图上道路、水域、街区、植被、景观及建筑物等要素,"用二维的表达方法创作出三维仿真的视觉效果",使读者从平面地图产品中体会到立体地图的艺术...
AUTOCAD-三种箭头的画法.docx
12-15
第三种方法是使用快捷键 AAE，指定两点即可绘制箭头。这方法相比第二种方法更加方便快捷，只需要两点的坐标信息。 箭头的基本概念 在 AUTOCAD 中，箭头是一种基本的绘图元素，用于表示方向、距离或其他信息。箭头...
图的3种表示方法
weixin_30861459的博客
02-27 133
//邻接矩阵 #include<stdio.h> #include<string.h> int main() { int map[101][101]; memset(map,0,sizeof(map)); int u, v, w; int m, n ,i; scanf("%d %d",&am...
图的基本表示方法
kuxingseng123的博客
11-27 2301
慢慢的将各种图网络都研究一波，全部将其搞定都行啦的理由与打算。
图的表示方式
weixin_45301190的博客
10-09 294
图的表示方式有两种: 二维数组表示(邻接矩阵) ; 链表表示(邻接表)。 邻接矩阵 邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵是的row和col表示的是…n个点。 邻接表 1）邻接矩阵需要为每个顶点都分配n个边的空间，其实有很多边都是不存在,会造 成空间的一定损失. 2）邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接 表由数组+链表组成 ➢说...
实验数据与结果的三种表示方法
本资料主要讲述了实验数据的三种表达方式：列表法、图解法和数学方程式法。 1. **列表法** 列表法是最基础的数据呈现方式，它清晰地列出各项数据，便于对比和分析。例如，"Table1.Physicalpropertiesofbenzene." ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值