图

最新推荐文章于 2023-02-03 10:03:56 发布
最新推荐文章于 2023-02-03 10:03:56 发布
阅读量392 收藏
点赞数
分类专栏： Algorithm&Data Structures
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Coding_Peasant/article/details/73555143
版权

图（graph）：结点之间的关系可以是任意的，图中任意两个数据之间都可能相关。二元组定义：图G是一个二元组（V,E），其中V称为顶点集（Vertexes Set）；E称为边集（Edges Set）。有向图：VR是两个顶点之间的关系集合；若，则表示从v到w的一条弧（arc），且称v为弧尾（tail）或初始点（initialnode），称w为弧头（head）或终端点（terminal node），此时的图称为有向图（Digraph）。无向图：若必有，即VR是对称的，则以无序对（v,w）代替这两个有序对，表示v和w之间的一条边（edge），此时的图称为无向图（Undigraph）。
注：1.完全图（completed graph）：有条边的无向图。有向完全图:具有条弧的有向图。2.稀疏图（sparse graph）：有很少条边或弧的图；反之称为稠密图（densegraph）。3.权（weight）：图的边或弧具有与它相关的数称为权。网（network）：权可以表示从一个顶点到另一个顶点的距离或耗费，这种带权的图称为网。4.邻接点（adjacent）：对于无向图,如果边，则称顶点v和w互为邻接点；顶点v的度（degree）是：和v相关联的边的数目，记为TD(v)。对于有向图，如果弧，则称顶点v邻接到顶点w，顶点w邻接自顶点v；以v为头的弧的数目称为v的入度（InDegree），记为ID(v)；以v为尾的弧的数目称为的出度（OutDegree），记为OD(v)；则顶点v的为TD(v)=ID(v)+OD(v)。度和有n个顶点、e个边或弧的图的关系：。5.连通图（connected graph）：对于无向图G中任意两个顶点、，从到有路径；则称G是连通图。对于有向图G任意两个顶点、，，从到和从到都存在路径；则称G是强连通图。6.生成树：一个连通图的生成树是一个极小连通子图，它含有图中全部顶点，但只有足以构成一颗树的n-1条边。一棵有n个顶点的生成树有且仅有n-1边；若一个图有n个顶点和小于n-1条边，则是非连通图；如果它多于n-1条边，则一定有环；但是有n-1条边的图不一定是生成树（对于连通图，遍历图过程中经历的所有边的集合和图中所有顶点一起构成连通图的极小连通子图；它是连通图的一颗生成树，并且称由深度优先搜索得到的为深度优先生成树；由广度优先搜索得到的为广度优先生成树。对于非连通图，每个连通分量中的顶点集，和遍历时走过的边一起构成若干棵生成树，这些连通分量的生成树组成非连通图的生成森林）。最小生成树（minimum cost spanning tree）：构造连通网络的最小代价生成树。7.存储结构：由于图的结构比较复杂，任意两个顶点之间都可能存在联系，因此无法以数据在存储区中的物理位置来表示元素之间关系，即图没有顺序映像的存储结构，但可以借助数组的数据类型表示元素之间的关系。另一方面，用多重链表表示图是自然的事，它是一种最简单的链式映像结构，即以一个由一个数据和多个指针域组成的结点表示图中的一个顶点，其中数据域存储该顶点的信息，指针域存储指向其邻接点的指针（结点的度不同造成结点设计不同）。1）数组表示（邻接矩阵）：以二维数组表示有n个顶点的图时，需要存放n个顶点和n2个弧信息的存储量。2）邻接表（adjacencylist）：是图的一种链式存储结构。在邻接表中，对图中每个结点建立一个单链表，第i个单链表中的结点表示依附于顶点vi的边（对有向图是以顶点vi为尾的弧）。表结点由3个域组成：邻接点域指示与顶点vi邻接的点在图的位置；链域指示下条边或弧的结点；数据域存储和边或弧相关的信息。头结点：链域指向链表中第一个结点；数据域存储顶点名或其他信息。头结点通常以顺序结构的形式存储，以便随机访问任一顶点的链表。3）十字链表（orthogonal list）：是有向图的另一种链式存储结构。可以看成是将有向图的邻接表和逆邻接表结合起来得到的一种链表。在十字链表中，对应于有向图中每条弧有一个弧结点，对应于每个顶点也有一个头结点。弧结点：其中尾域（tailvex）和头域（headvex）分别指示弧尾和弧头这两个顶点在图中的位置；链域hlink指向弧头相同的下一条弧，而链域tlink指向弧尾相同的下一条弧；info域指向该弧的相关信息。顶点结点：data域存储和顶点相关的信息，firstin和firstin为两个链域，分别指向以该顶点为弧头或弧尾的第一个弧结点。4）邻接多重表（adjacency multilist）：是无向图的另一种链式存储结构。在邻接多重表中，每一条边用一个边结点表示，每一个顶点也用一个头结点表示。边结点：mark为标志域，可用以标记该条边是否被搜索过；ivex和jvex为该边依附的两个顶点在图中的位置；iline指向下一条依附于顶点ivex的边，jlink指向下一条依附于顶点jvex的边；info为指向和边相关的信息的指针域。头结点：data域存储和该顶点相关的信息；firstedge域指示第一条依附于该顶点的边。8.图的遍历（traverse graph）：从图中某个顶点出发遍历图中其余顶点，且使每一个顶点仅被访问一次。为避免同一顶点被访问多次访问，为此设置一个数组visited[n]。两条遍历图的路径：深度优先搜索和广度优先搜索。它们对无向图和有向图都适用。（1）深度优先搜索（DepthFirst Search,DFS）：又称回溯法，其采用了一种“一直向下走，走不通就掉头”的思想；类似于树的先根遍历，是树的先根遍历的推广。用邻接表存储时时间复杂度为O(v+e)。
基本思路：从图的某个顶点V出发，访问此顶点；然后依次从V的未被访问的邻接点出发深度优先遍历图，直至图中所有和V有路径相通的顶点都被访问到；若此时图中尚有顶点未被访问到，则另选图中一个未曾被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止（有递归和非递归实现的算法-利用栈stack来实现）。DFS对于寻找一个解的NP问题作用很大，提高深度优先搜索的效率最具通用性的是剪枝（prunning）即去除没有用的搜索分支。（2）广度优先搜索（BreadthFirst Search）：类似于树的按层次遍历的过程。其过程是以v为起始点，由近及远，依次访问和v有路径相通且路径长度为1,2,3…顶点。用邻接表存储时时间复杂度为O(v+e)。基本思想：从图中的某顶点出发，在访问了V之后依次访问V的各个未曾访问过的邻接点；然后分别从这些邻接点出发依次访问它们的邻接点，并使“先被访问的顶点的邻接点”先于“后被访问的顶点的邻接点”被访问；直至图中所有已被访问的顶点的邻接点都被访问到。若此时图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作起始，重复上述过程，直至图中所有顶点都被访问到为止（利用队列queue实现）。应用在最短路径上较多。9.拓扑排序（topologicalsort）：对于一个有向无环图，将其所有顶点排成一个线性序列，使得图中任意一对顶点v和u，若弧，则v在线性序列中出现在v之前。简单的说，由某个集合上的一个偏序得到该集合上的一个全序，且这个全序称为拓扑有序。AOV-网（activity on vertex network）：用顶点表示活动，用弧表示活动间的优先关系的有向图称为顶点表示活动的网。拓扑排序方法：1）在有向图中选一个没有前驱（入度为零）的顶点且输出之。2）从图中删除该顶点和所有以它为尾的弧。重复上述两步直至全部顶点均已输出；或者当前图中不存在无前驱的顶点为止（有向图中存在环）。AOE-网（activity on edge）：用顶点表示事件，弧表示活动，权表示活动持续的时间的带权的有向无环图称为边表示活动的网。10.最短路径（shortest path）：一个顶点到另一个顶点的最短路径（路径上边的数目/路径上边的权值之和）。（1）单源最短路径：从某个源点到其余各顶点的最短路径。1）Dijkstra算法：又称SPF（shortest path first最短路径优先）算法；求不含有负权环图的单源最短路径。算法思想：设是一个带权有向图，把图中顶点集合V分成两组：第一组为已求出最短路径的顶点集合（用S表示，初始时S中只有一个源点，以后每求得一条最短路径，就将加入到集合S中，直到全部顶点都加入S中为止）；第二组为其余未确定最短路径的顶点集合（用U表示）。按最短路径长度的递增次序依次把第二组U中的顶点加入S中；在加入的过程中，总保持从源点到S中各顶点的最短路径长度不大于从源点到U中任何顶点的最短路径长度。从而求得从到图上其余各个顶点的最短路径是路径长度递增的序列（即D[v]）。时间复杂度为。2）Bellman-Ford算法:求含负权图的单源最短路径。时间复杂度为。3）SPFA（shortestpath faster algorithms）算法：求含有负权环的图单源最短路径算法。是在bellman-ford算法的基础上加上一个队列优化，减少了冗余的松弛操作。时间复杂度为。注：松弛操作（relaxation）：对于每个顶点，都设置一个属性d[v]，用来描述从源点s到v的最短路径权值的上界。一次松弛操作可以减少最短路径估计的值d[v]，并更新当前最短路径。（2）多源最短路径：每一对顶点之间的最短路径。Floyd算法：又称插点法；是一种动态规划算法，边权可正可负。算法思想：若（vi,… ,vk）和（vk , … ,vj）分别是从vi到vk和从vk到vj的中间顶点的序号不大于K-1的最短路径，则将（vi, … ,vk , …vj）和已经得到的从vi到vj且中间顶点序号不大于K-1的最短路径相比较，其长度较短者便是从vi到vj的中间顶点的序号不大于k的最短路径。这样比较n次后最后求得的必是从vi到vj的最短路径。时间复杂度。

#include <stdlib.h>
#include <iostream>
#include <queue>
#define MAX_VERTEX_NUM8

using namespacestd;
enum GraphKind{DG,DN,UDG,UDN};//{有向图，有向网，无向图，无向网}
typedef structArcNode{
         intadjvex; //该弧所指向的顶点或边的另一个顶点的位置
         ArcNode *nextArc;//指向下一条弧或边的指针
         //infoType*info; //该弧/边相关信息的指针
}ArcNode; //表/弧/边结点
typedef struct{
         chardata; //顶点信息
         ArcNode *firstArc;//第一个表结点的地址，指向第一条依附该顶点的弧或边指针
}VNode; //头结点
typedef struct{
         VNode headArray[MAX_VERTEX_NUM];//头结点数组
         intvexNum, arcNum; //图的当前顶点数和弧/边数
         GraphKind kind;//图的种类标志
}Graph; //图
//创建一个固定的图
Graph* createGraph(){
         Graph* graph = (Graph*)malloc(sizeof(Graph));
         graph->vexNum= 8;
         graph->arcNum= 18;
         graph->kind= UDG;
         for(inti = 0; i <MAX_VERTEX_NUM; i++)
                   graph->headArray[i].data= 'A' + i;
         //为每个表/弧/边结点分配空间Pnm表示以第n+1个为顶点的第m+1个弧/边j结点
         ArcNode *p00 = (ArcNode*)malloc(sizeof(ArcNode));
         ArcNode *p01 = (ArcNode*)malloc(sizeof(ArcNode));
         ArcNode *p10 = (ArcNode*)malloc(sizeof(ArcNode));
         ArcNode *p11 = (ArcNode*)malloc(sizeof(ArcNode));
         ArcNode *p12 = (ArcNode*)malloc(sizeof(ArcNode));
         ArcNode *p20 = (ArcNode*)malloc(sizeof(ArcNode));
         ArcNode *p21 = (ArcNode*)malloc(sizeof(ArcNode));
         ArcNode *p22 = (ArcNode*)malloc(sizeof(ArcNode));
         ArcNode *p30 = (ArcNode*)malloc(sizeof(ArcNode));
         ArcNode *p31 = (ArcNode*)malloc(sizeof(ArcNode));
         ArcNode *p40 = (ArcNode*)malloc(sizeof(ArcNode));
         ArcNode *p41 = (ArcNode*)malloc(sizeof(ArcNode));
         ArcNode *p50 = (ArcNode*)malloc(sizeof(ArcNode));
         ArcNode *p51 = (ArcNode*)malloc(sizeof(ArcNode));
         ArcNode *p60 = (ArcNode*)malloc(sizeof(ArcNode));
         ArcNode *p61 = (ArcNode*)malloc(sizeof(ArcNode));
         ArcNode *p70 = (ArcNode*)malloc(sizeof(ArcNode));
         ArcNode *p71 = (ArcNode*)malloc(sizeof(ArcNode));
         //为表/弧/边结点的属性赋值
         p00->adjvex= 1;  //该弧所指向的顶点或边的另一个顶点的位置
         p00->nextArc= p01; ///指向下一条弧或边的指针
         p01->adjvex= 2;
         p01->nextArc= NULL;
         p10->adjvex= 0;
         p10->nextArc= p11;
         p11->adjvex= 3;
         p11->nextArc= p12;
         p12->adjvex= 4;
         p12->nextArc= NULL;
         p20->adjvex= 0;
         p20->nextArc= p21;
         p21->adjvex= 5;
         p21->nextArc= p22;
         p22->adjvex= 6;
         p22->nextArc= NULL;
         p30->adjvex= 1;
         p30->nextArc= p31;
         p31->adjvex= 7;
         p31->nextArc= NULL;
         p40->adjvex= 1;
         p40->nextArc= p41;
         p41->adjvex= 7;
         p41->nextArc= NULL;
         p50->adjvex= 2;
         p50->nextArc= p51;
         p51->adjvex= 6;
         p51->nextArc= NULL;
         p60->adjvex= 2;
         p60->nextArc= p61;
         p61->adjvex= 5;
         p61->nextArc= NULL;
         p70->adjvex= 3;
         p70->nextArc= p71;
         p71->adjvex= 4;
         p71->nextArc= NULL;
         //将顶点与每个链表连接起
         graph->headArray[0].firstArc= p00;
         graph->headArray[1].firstArc= p10;
         graph->headArray[2].firstArc= p20;
         graph->headArray[3].firstArc= p30;
         graph->headArray[4].firstArc= p40;
         graph->headArray[5].firstArc= p50;
         graph->headArray[6].firstArc= p60;
         graph->headArray[7].firstArc= p70;
         returngraph;
}

int visited[MAX_VERTEX_NUM]= {0};//全局变量用来保存结点的访问信息
/*
* DFSTraverse
*函数功能：又称回溯法，其采用了一种“一直向下走，走不通就掉头”的思想；
*          类似于树的先根遍历，是树的先根遍历的推广
*输入：图graph
*返回值：void
*/

//DFS:Depth First Search
void DFS(Graph*graph,intv){
         cout<< graph->headArray[v].data;
         visited[v]= 1;
         //对于无向图，可以遍历到v顶点所在的连通分量中的所有顶点；
         //而对于有向图可以遍历到起始顶点v能够到达的所有顶点
         ArcNode* nextArc =graph->headArray[v].firstArc;//顶点v的第一条弧/边
         for(intw = nextArc->adjvex; nextArc!=NULL&& w >= 0; nextArc = nextArc->nextArc){
                   w= nextArc->adjvex; //顶点v的下一个邻接点
                   if(!visited[w])
                            DFS(graph,w);//对v的尚未访问的邻接点w递归调用DFS
         }
}

void DFSTraverse(Graph*graph){
         for(intv = 0; v <graph->vexNum;v++){
                   if(!visited[v])
                            DFS(graph,v);
         }
}

/*
* BFSTraverse
*函数功能：类似于树的按层次遍历的过程。其过程是以v为起始点，由近及远，
*          依次访问和v有路径相通且路径长度为1,2,3…顶点。
*          用邻接表存储时时间复杂度为O(v+e)
*输入：图graph
*返回值：void
*/

//BFS:Breadth First Search
void BFS(Graph*graph,intv){
         queue<int> q;
         cout<< graph->headArray[v].data;
         visited[v]= 1;
         q.push(v);
         inti;
         while(!q.empty()){
                   i= q.front();
                   q.pop();
                   ArcNode* nextArc =graph->headArray[i].firstArc;//顶点i的第一条弧/边
                   for(intw = nextArc->adjvex; nextArc !=NULL&& w >= 0; nextArc = nextArc->nextArc){
                            w= nextArc->adjvex; //顶点v的下一个邻接点
                            if(!visited[w]){
                                     cout<< graph->headArray[w].data;
                                     visited[w]= 1;
                                     q.push(w);
                            }
                   }
         }
}

void BFSTraverse(Graph*graph){
         for(inti = 0; i <graph->vexNum;i++){
                   if(!visited[i])
                            BFS(graph,i);
         }
}
/*
*shortestPathDIJ
*函数功能：求从v0到其余顶点v的最短路径
*输入：顶点个数n,源顶点v0
*返回值：void
*/
int arcs[6][6] = {1000000,1000000,10,100000, 30 ,100,
1000000,1000000, 5 ,1000000, 1000000, 1000000,
1000000 ,1000000 ,1000000, 50 ,1000000 ,1000000,
1000000 ,1000000, 1000000, 1000000, 1000000, 10,
1000000 ,1000000, 1000000 ,20 ,1000000, 60,
1000000 ,1000000 ,1000000, 1000000 ,1000000, 100000}; //邻接矩阵
int path[6][6]; //path[v][w]=1,则w是从v0到v当前求得最短路径上的顶点
                      //path[v]是从v0到其余顶点v的最短路径
int D[6]; //从v0到其余顶点v的最短路径的带权长度D[v]
int final[6]; //final[v]=1,顶点v在集合S中；已经求得从v0到v的最短路径
void shortestPathDIJ(intn,intv0){
         intv, w;
         //初始化
         for(v = 0; v < n;v++){
                   final[v]= 0;
                   D[v]= arcs[v0][v];
                   for(w = 0; w <n; w++)
                            path[v][w]= 0; //设空路径
                   if(D[v] < 1000000){//1000000代表无穷，说明从v0到v有直接路径
                            path[v][v0]= 1;
                            path[v][v]= 1;
                   }
         }
         D[v0]= 0;
         final[v0]= 0; //初始化v0顶点属于集合S
         //每次求得v0到某个v顶点的最短路径，并加v到S集
         for(inti = 0; i <n;i++){
                   intmin = 1000000;
                   for(w = 0; w <n;w++)
                            if(!final[w]){ //w顶点V-S中
                                     if(D[w]<min){
                                               v= w;
                                               min= D[w]; //w顶点离v0顶点更近
                                     }
                            }
                   final[v]= 1; //离v0顶点最近的v加入S集
                   for(w = 0; w <n;w++) //更新当前最短路径及距离
                            if(!final[w]&&(min+arcs[v][w])<D[w]){
                                     D[w]= min + arcs[v][w];
                                     *path[w]=* path[v]; //使path[w]= path[v];
                                     path[w][w]= 1;
                            }
         }
}

/*
*shortestPathFloyd
*函数功能：求每一对顶点的最短路径
*输入值：邻接矩阵的顶点数n
*返回值：void
*/
int Path[6][6][6]; //若Path[v][w][u]=1;则u是从v到w当前求得最短路径上的顶点
                 //Path[v][w]是各对顶点从v到w的最短路径
int Distance[6][6]; //从v到w的最短路径的带权长度D[v][w]
void shorestPathFloyd(intn){
         intv, w, u;
         //初始化各对结点之间初始已知路径及距离
         for(v = 0; v < n; v++)
                   for(w = 0; w <n; w++){
                            Distance[v][w]= arcs[v][w];
                            for(u = 0; u <n; u++)
                                     Path[v][w][u]= 1;
                            if(Distance[v][w] < 1000000){//1000000代表无穷，说明从v到w有直接路径
                                     Path[v][w][v]= 1;
                                     Path[v][w][w]= 1;
                            }
                   }

         for(u = 0; u < n; u++) //u为从v到w经过的中间点
                   for(v = 0; v <n; v++)
                            for(w = 0; w <n;w++)
                                     if(Distance[v][u] + Distance[u][w] < Distance[v][w]){//更新当前最短路径及距离
                                               Distance[v][w]= Distance[v][u] + Distance[u][w];
                                               for(inti = 0; i < n; i++)
                                                        Path[v][w][i]= Path[v][u][i] || Path[u][w][i];
                                     }
}
Coding_Peasant
关注
专栏目录
数据结构之图（术语、存储结构、遍历）
u013071074的专栏
06-04 1万+
无向边：若顶点Vi 到Vj 的边没有方向，则称这条边为无向边，用无序偶对来表示
数据结构之图的基本概念
weixin_30727835的博客
04-21 450
一 图的定义 　　定义：图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,E)，其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。 　　在图中需要注意的是： 　　（1）线性表中我们把数据元素叫元素，树中将数据元素叫结点，在图中数据元素，我们则称之为顶点（Vertex）。 　　（2）线性表可以没有元素，称为空表；树中可以没有节点，称为空树...
数据结构_二元组
热门推荐
hhhhhyyyyy8的博客
07-09 3万+
今天在牛客网上看到这样一个题目：当时做的时候直接没反应过来，后来看解析的时候，才知道，二元组，图论上学过嘛。而且，我们以前也经常接触，图(V,E)就是嘛。下面的解释转载自：https://www.cnblogs.com/larryzeal/p/5095522.html数据结构分为：逻辑结构、存储结构。逻辑结构分为：集合、线性结构、树形结构、图形结构。    --线性表、栈、队列、树、图等逻辑结构。...
图之邻接表
suns的专栏
12-30 893
图的邻接表存储结构及其实现
【数据结构基础】图 - 基础和Overview
DeveloperFire的博客
02-03 1005
图(Graph)是由顶点和连接顶点的边构成的离散结构。在计算机科学中，图是最灵活的数据结构之一，很多问题都可以使用图模型进行建模求解。例如: 生态环境中不同物种的相互竞争、人与人之间的社交与关系网络、化学上用图区分结构不同但分子式相同的同分异构体、分析计算机网络的拓扑结构确定两台计算机是否可以通信、找到两个城市之间的最短路径等等。
点击图片弹出大图效果交互
08-03
在网页设计中，点击图片弹出大图效果是一种常见的交互设计，它为用户提供了一种查看高清晰度图像的便捷方式。这种效果通常通过JavaScript（JS）实现，因为JS具有动态控制网页元素的能力，可以轻松地处理用户的点击...
黑马程序员微信小程序-本地生活案例实现所用图片
最新发布
04-10
7. **加载中或占位符图**：在网络加载缓慢时，显示这些图片以提高用户体验，避免空白屏幕的尴尬。 8. **用户反馈和评价图**：展示其他用户对商品或服务的评价，增强可信度。 9. **引导教程图**：对于功能复杂的...
微信小程序上传图片包含多图上传，支持9图，无限制图片数目
02-23
本篇文章将深入探讨微信小程序如何实现多图上传，包括单图上传、9图上传以及无限制图片数目的上传策略。 首先，我们要了解微信小程序中的`wx.chooseImage`接口，这是用于选择本地相册或拍照获取图片的关键函数。它...
最全的android图片加密
11-26
在加密图片时，我们可以在原始数据中随机插入一些无关的字节，使得即使获取了加密后的数据，没有正确的“混入”规则也无法还原原图。这种方法可以进一步提高数据的安全性，防止针对AES等标准加密方式的攻击。 在...
基于VUE选择上传图片并页面显示（图片可删除）
08-30
基于VUE选择上传图片并页面显示（图片可删除） 本资源主要介绍了基于VUE选择上传图片并页面显示的效果，图片可以删除。该效果通过VUE框架实现图片上传和显示，并提供了删除图片的功能。下面我们将对该资源的知识点...
数据结构图的定义
超纯的小白兔
11-23 6186
一、图的存储结构 1.1 邻接矩阵 图的邻接矩阵存储方式是用两个数组来表示图。一个一维数组存储图中顶点信息，一个二维数组（邻接矩阵）存储图中的边或弧的信息。 设图G有n个顶点，则邻接矩阵是一个n*n的方阵，定义为： 看一个实例，下图左就是一个无向图。 从上面可以看出，无向图的边数组是一个对称矩阵。所谓对称矩阵就是n阶矩阵的元满足aij = aji。即从矩阵的
链表详解来啦
qq_62687015的博客
12-26 509
通过单向链表可以很方便的获取每一个接点的直接后继，但要获取直接前驱比较麻烦。其中包含数据域和链域。通常，链表的第一个结点不含任何数据信息，称为头结点，其链域为空时，链表为空链表。在单向链表中，可以高效的确定每一个结点的直接后继，但确定结点的直接前驱比较麻烦，从而查找效率降低。为了增加链表操作的灵活性，可以对单向链表做一些改变，得到另外两种类型的链表：双向链表和循环链表。
java实现-拓扑排序
StrongHYQ的博客
08-01 1606
import java.util.Stack; //拓扑排序 public class GraphTopologic { private int numVertexes; private VertexNode[] adjList;//邻接顶点的一维数组 public GraphTopologic(int numVertexes){ this.numV...
BFS
wysw1998的博客
11-05 436
为了简单，ABCD用1234来代替 #include<iostream> #include<stdio.h> #include<stdlib.h> using namespace std; typedef int VertexType; #define MaxVertexNum 100 // 需要设计两种结点结构类型：一是定点表的顶点，二是单链表的结点 ...
普里姆算法思路
菜鸟的逆袭
09-08 1万+
算法思想：可取图中任意一个顶点V作为生成树的根，之后若要往生成树上添加顶点W，则在顶点V和W之间必定存在一条边。并且该边的权值在所有连通顶点V和W之间的边中取值最小。 一般情况下，假设n个顶点分成两个集合：U（包含已落在生成树上的结点）和V-U（尚未落在生成树上的顶点），则在所
深度优先算法（DFS）
勇敢的俍心的博客
05-25 5367
前言：英文缩写为DFS，可笑的是，我最早去HP公司面试做笔试题的时候， 竟然没看出来是什么意思，当然即使知道是这个算法，当时也不太会写。本科都是学过的，就是后来忘记了。 思路说明：理解深度优先算法的关键在于解决“当下该如何做”。至于下一步应该如何做，和当下应该如何做是一样的，对！就是用递归！自己调用自己！ 递归函数模型： void dfs(int step) { 判断边界，如果到了边界当然直
对普里姆算法的一点理解
THE_ONE_ZHS的博客
10-28 2608
普里姆算法是构造连通网的最小生成树的算法之一。理解普里姆算法的关键就是要明确两个数组是用来干什么的，这两个数组分别是:lowcost和adjvex。lowcost[j]的意思是顶点j和已经在生成树内的顶点集合内的某个顶点的最小权值。这个已经在生成树内且与顶点j对应的顶点，就记录在adjvex[j]中。把adjvex[j]和lowcost[j]对应起来的意思就是:已经属于生成树的顶点adjvex[j
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值