数据结构学习日记四：图

最新推荐文章于 2024-09-14 15:47:59 发布
最新推荐文章于 2024-09-14 15:47:59 发布
阅读量97 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63494746/article/details/132515684
版权

数据结构学习笔记

七、图

1、邻接矩阵

用Graph[N][N]存储N个顶点的边信息。因为边的信息的对称，使用 n(n+1)/2的一维数组存储，来节省空间。

查询某条边Vij：前面 i-1 行的个数 + j 列。

概念：

  • 邻接点：对于一个顶点，跟它有边直接相连的顶点。
  • 度；出度：从该点发出的边数；入度：指向该点的边数。
    • 无向图：对应行（或列）非0元素的个数；
    • 有向图：对应行非0元素的个数是“出度”；对应列非0元素的个数是“入度”。

邻接矩阵的不好：

当图是稠密图，用邻接矩阵很好；当图是稀疏图（点多边少），有大量的的无效元素，浪费空间，浪费时间。

2、邻接表

G[N] 为指针数组，对应矩阵每行一个链表，只存非0元素。

好处：

  • 方便找任一顶点的所有邻接点；
  • 适合特稀疏的稀疏图

3、图的遍历

3.1 深度优先搜索

（Depth First Search, DFS）

void DFS(Vertex V){
    visited[V] = true;
    for(V 的每个邻接点 W)
        if( !visited[W] )
            DFS(W);
}

时间复杂度

若有N个顶点、E条边。

用邻接表存储，有O(N+E); 用邻接矩阵存储图，有O(N2)。

3.2 广度优先搜索

(Breadth First Search, BFS).

void BFS(Vertex V){
    visited[V] = true;
    Enqueue(V, Q);
    while(!IsEmpty(Q)){
        V = Dequeue(Q);
        for(V 的每个邻接点 W)
            if(!visited[W]){
                visited[W] = true;
                Enqueue(W, Q);
            }
    }
}

时间复杂度和DFS一样。

3.3 图不连通的解决方法

void ListComponents(Graph G){
    for(each V in G)
        if(!visited[V]){
            DFS(V);	//或者BFS(V)
        }
}

4、用邻接矩阵表示图

4.1 规范写法

typedef struct GNode* PtrToGNode;	//定义成指针，方便函数调用
struct GNode{
    int Nv;	//顶点数
    int Ne;	//边数
    WeightType G[MaxVertexNum][MaxVertexNum];	//邻接矩阵
    /*
    	//有时候，顶点具有特别的信息，需要定义DataType类型存储。
    	DataType Data[MaxVertexNum];	//存顶点的数据。
    */
};
typedef PtrToGNode MGraph;	//以邻接矩阵存储的图类型

//初始化一个有VertexNum个顶点但没有边的图
typedef int Vertex;	//用顶点下标表示顶点，为整型
MGraph CreateGraph(int VertexNum){
    Vertex V, W;
    MGraph Graph;
    
    Graph = (MGraph)malloc(sizeof(struct GNode));
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    
    //默认顶点编号从0开始
    for(V=0; V<Graph->Nv; V++)
        for(W=0; W<Graph->Nv; W++)
            Graph->G[V][W] = 0;	//或者INFINITY
    
    return Graph;
}

//插入一条边
typedef struct ENode* PtrToENode;
struct ENode{
    Vertex V1, V2;	//有向边<V1,V2>
    WeightType Weight;	//权重
};
typedef PtrToENode Edge;

void InsertEdge(MGraph Graph, Edge E){
    Graph->G[E->V1][E->V2] = E->Weight;
    
    //如果是无向图，还要插入边<V2,V1>
    Graph->G[E->V2][E->V1] = E->Weight;
}

//根据上面两个函数，建立一个MGraph
MGraph BuildGraph(){
    MGraph Graph;
    Edge E;
    Vertex V;
    int Nv, i;
    
    scanf("%d", &Nv);
    Graph = CreateGraph(Nv);
    scanf("%d", &(Graph->Ne));
    if(Graph->Ne != 0){
        E = (Edge)malloc(sizeof(struct ENode));
        for(i=0; i<Graph->Ne; i++){
            scanf("%d %d %d",
                 	&E->V1,&E->V2,&E->Weight);
            InsertEdge(Graph, E);
        }
    }
    
    //如果顶点还有具体信息，读入数据
    /*
    for(V=0; V<Graph->Nv; V++)
    	scanf(" %c", &(Graph->Data[V]));
    */
    
    return Graph;
}

4.2 简洁写法

int G[MAXN][MAXN], Nv, Ne;
void BuildGraph(){
    int i, j, v1, v2, w;
    
    scanf("%d", &Nv);
    //CreateGraph初始化图
    for(i=0; i<Nv; i++)
        for(j=0; j<Nv; j++)
            G[i][j] = 0;	//或INFINITY
    scanf("%d", &Ne);
    for(i=0; i<Ne; i++){
        scanf("%d %d %d", &v1, &v2, &w);
        //InsertEdge插入边
        G[v1][v2] = w;
        G[v2][v1] = w;
    }
}

5、用邻接表表示图

//图
typedef struct GNode* PtrToGNode;
struct GNode{
    int Nv;	//顶点数
    int Ne;	//边数
    AdjList G;	//邻接表
};
typedef PtrToGNode LGraph;

//邻接表
typedef struct Vnode{
    PtrToAdjVNode FirstEdge;
    //DataType Data;	//存顶点数据
} AdjList[MaxVertexNum];	//邻接表类型,顶点数组，边链表

//边
typedef struct AdjVNode* PtrToAdjVNode;
struct AdjVNode{
    Vertex AdjV;	//邻接点下标
    WeightType Weight;	//边权重
    PtrToAdjVNode Next;
}

//初始化一个有VertexNum个顶点但没有边的图
typedef int Vertex;	//用顶点下标表示顶点，为整型
LGraph CreateGraph(int VertexNum){
    Vertex V, W;
    LGraph Graph;
    
    Graph = (LGraph)malloc(sizeof(struct GNode));
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    
    for(V=0; V<Graph->Nv; V++)
        Graph->G[V].FirstEdge = NULL;
    
    return Graph;
}

void InsertEdge(LGraph Graph, Edge E){
    PtrToAdjVNode NewNode;
    //插入边<V1,V2>
    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = E->V2;
    NewNode->Weight = E->Weight;
    //将V2插入V1的表头
    NewNode->Next = Graph->G[E->V1].FirstEdge;
    Graph->G[E->V1].FirstEdge = NewNode;
    
    //如果是无向图，还要插入边 <V2,V1>
}

LGraph BuildGraph(){
    LGraph Graph;
    //...仿照邻接矩阵的
}

6、最短路径问题

  • 单源最短路径问题：从某个固定起点出发，求其到所有其他顶点的最短路径。
    • 无权图
    • 有权图
  • 多源最短路径问题：求任意两顶点间的最短路径。

6.1 无权图的单源最短路径算法

初始化:

dist[W] = S到W的最短距离；

dist[S] = 0;

path[W] = S到W的路上经过的某个顶点。

//改编BFS，
//因为是广度优先，所以第一次访问到顶点，就一定是最短路径
void ShortestPath(Vertex S){
    Enqueue(S,Q);
    while(!IsEmpty(Q)){
        V = Dequeue(Q);
        for( V 的每个邻接点 W )
            if(dist[W] == -1){	//-1表示当前结点未访问过，也可以是负无穷或者正无穷
                dist[W] = dist[V] + 1;//路径长度加1
                path[W] = V;		//记录该边的起点
                Enqueue(W, Q);
            }
    }
} 
//最终结果：dist[]数组存着起点到任意点的最短距离
//		  path[]能够回溯路过的顶点。

6.2 有权图的单源最短路径算法

有权图的最短路径不一定是经过顶点数少的。

6.2.1 Dijkstra算法（贪心）

  • 假设有一个集合S = { 源点s + 已经确定了最短路径的顶点vi }

  • 任一为收录集合的顶点v的最短路径，只经过集合S中的顶点。
    即 dist[v] = 【S →(vi∈S）→ v】的最小长度。

  • 要求路径是按照递增的顺序生成的，则

    • 最短路必须只经过S中的顶点；

    • 每次从未收录的顶点中选一个dist最小的收录（贪心）；

    • 增加一个新的顶点进入集合S中，可能影响它一圈邻接点的dist值。

      假设 w 是 v 的 邻接点，

      ​ dist[w] = min{dist[w], dist[v] + <v,w>的权重}

//dist[]初始化是正无穷
//path[]初始化为-1，找路径的时候值为-1的是起点
void Dijkstra(Vertex s){
    while(1){
        V = 未收录顶点中dist最小者;
        
        if( 找不到V )//说明访问完了 
            break;
        
        collected[V] = true;	//塞进集合
        for( V 的每个邻接点 W)	//修改V的邻接点的dist值
            if(collected[W] == false)	//未收录集合
                if(dist[V]+<V,W>的权重 < dist[W]){
                    dist[W] = dist[V] + <V,W>的权重;
                    path[W] = V;
                }
    }
}

Dijkstra算法不能解决有负边的情况。

如何扫描出未收录顶点中dist最小者：

  • 方法一：直接遍历所有，时间复杂度O(V2+E)，适合稠密图；
  • 方法二：将dist存在最小堆中，时间复杂度O(E logV)，适合稀疏图。
6.2.2 Dijkstra算法的应用
  • 要求数最短路径有多少条
    • count[s] = 1; 初始化起点的条数为1
    • 如果找到更短路：count[W] = count[V];
    • 如果找到等长路：count[W] += count[V];
  • 要求边数最少的最短路（或者旅游规划问题想要费用最少的路径）
    • 边数最少相当于边的权重值都变成1。
    • count[s] = 0; 初始化起点的边数是0。自己到自己边数为0。
    • 如果找到更短路：count[W] = count[V] + 1;
    • 如果找到等长路：count[W] = count[V] + 1;

6.3 多源最短路径算法

方法一：直接将单源最短路径算法调用V遍，时间复杂度O(V3+EV);

方法二：Floyd算法，时间复杂度O(V3);

6.3.1 Floyd算法

  • Dk[i][j] = 路径 i→j 的最小长度，经过顶点数 ≤ k。

  • 最初的D-1是邻接矩阵，对角线初始化为0，D[i][j]就是E<i,j>边值，不连通就是正无穷。

  • D0, D1, …, DV-1就得到正确的最短路径了

  • 当Dk-1完成后，递推到Dk时：

    • 加入新的结点，路径不能更短，即Dk = Dk-1；

    • 加入新的结点k，路径变短，则最短路径长度是：

      ​ Dk[i][j] = Dk-1[i][k] + Dk-1[k][j]

void Floyd(){
    for(i = 0; i < N; i++ )
        for(j = 0; j < N; j++){
            D[i][j] = G[i][j];
            path[i][j] = -1;
        }
    for(k = 0; k < N; k++)
        for(i = 0; i < N; i++)
            for(j = 0; j < N; j++)
                if(D[i][k] + D[k][j] < D[i][j]){
                    D[i][j] = D[i][k] + D[k][j];
                    path[i][j] = k;
                    if(i==j && D[i][j]<0)	//出现负值圈
                        return false;	//不能正确解决，退出
                }
}

7、最小生成树问题

定义：

  • 是树：无回路；V个顶点，V-1条边
  • 是生成树：包含图中的全部顶点；V-1条边都在图里
  • 最小：边的权重和最小

7.1 Prim算法（贪心）

类似Dijkstra。

适合稠密图。暴力的时间复杂度为：O(V2)

//dist[V]：初始化为根结点到V的长度E<s,V> 或者 正无穷
//parent[s]: 初始化为-1
void Prim(){
    MST = {s};	//创建最小生成树，塞入s作为根结点
    while(1){
        V = 未收录顶点中 dist 最小者;
        if(这样的 v 不存在)
            break;
        dist[V] = 0;	//将 v 收录进 MST
        for( V 的每个邻接点 W)
            if(dist[W] != 0)	//W 未被收录 
                if( E<V,W> < dist[W]){
                    dist[W] = E<V,W>;
                    parent[W] = V;
                }
    }
    if( MST 中的顶点不到 V 个)	//说明图不连通
        Error("生成树不存在");
}

/* 邻接矩阵存储 - Prim最小生成树算法 */

Vertex FindMinDist( MGraph Graph, WeightType dist[] )
{ /* 返回未被收录顶点中dist最小者 */
    Vertex MinV, V;
    WeightType MinDist = INFINITY;

    for (V=0; V<Graph->Nv; V++) {
        if ( dist[V]!=0 && dist[V]<MinDist) {
            /* 若V未被收录，且dist[V]更小 */
            MinDist = dist[V]; /* 更新最小距离 */
            MinV = V; /* 更新对应顶点 */
        }
    }
    if (MinDist < INFINITY) /* 若找到最小dist */
        return MinV; /* 返回对应的顶点下标 */
    else return ERROR;  /* 若这样的顶点不存在，返回-1作为标记 */
}

int Prim( MGraph Graph, LGraph MST )
{ /* 将最小生成树保存为邻接表存储的图MST，返回最小权重和 */
    WeightType dist[MaxVertexNum], TotalWeight;
    Vertex parent[MaxVertexNum], V, W;
    int VCount;
    Edge E;
    
    /* 初始化。默认初始点下标是0 */
    for (V=0; V<Graph->Nv; V++) {
        /* 这里假设若V到W没有直接的边，则Graph->G[V][W]定义为INFINITY */
        dist[V] = Graph->G[0][V];
        parent[V] = 0; /* 暂且定义所有顶点的父结点都是初始点0 */ 
    }
    TotalWeight = 0; /* 初始化权重和     */
    VCount = 0;      /* 初始化收录的顶点数 */
    /* 创建包含所有顶点但没有边的图。注意用邻接表版本 */
    MST = CreateGraph(Graph->Nv);
    E = (Edge)malloc( sizeof(struct ENode) ); /* 建立空的边结点 */
           
    /* 将初始点0收录进MST */
    dist[0] = 0;
    VCount ++;
    parent[0] = -1; /* 当前树根是0 */

    while (1) {
        /* V = 未被收录顶点中dist最小者 */
        V = FindMinDist( Graph, dist );
        if ( V == ERROR ) /* 若这样的V不存在 */
            break;   /* 算法结束 */
            
        /* 将V及相应的边<parent[V], V>收录进MST */
        E->V1 = parent[V];
        E->V2 = V;
        E->Weight = dist[V];
        InsertEdge( MST, E );
        TotalWeight += dist[V];
        dist[V] = 0;
        VCount++;
        
        for( W=0; W<Graph->Nv; W++ ) /* 对图中的每个顶点W */
            if ( dist[W]!=0 && Graph->G[V][W]<INFINITY ) {
            /* 若W是V的邻接点并且未被收录 */
                if ( Graph->G[V][W] < dist[W] ) {
                /* 若收录V使得dist[W]变小 */
                    dist[W] = Graph->G[V][W]; /* 更新dist[W] */
                    parent[W] = V; /* 更新树 */
                }
            }
    } /* while结束*/
    if ( VCount < Graph->Nv ) /* MST中收的顶点不到|V|个 */
       TotalWeight = ERROR;
    return TotalWeight;   /* 算法执行完毕，返回最小权重和或错误标记 */
}

7.2 Kruskal算法 - 将森林合并成树

每次去图中找一条最小权重的边，且不构成回路。

时间复杂度：O(ElogE)。适合稀疏图。

void Kruskal(Graph G){
    MST = {};
    while( MST 中不到 V-1 条边 && E中还有边){
        从 E 中取一条权重最小的边E<V,W>;	//最小堆，实现
        将 E<V,W> 从 E 中删除;
        if( E<V,W> 不在 MST 中构成回路)	//并查集
            将E<V,W> 加入MST;
        else
            彻底无视 E<V,W>;
    }
    if( MST 中的不到 V-1 条边)	//说明图不连通
        Error("生成树不存在");
}

/* 邻接表存储 - Kruskal最小生成树算法 */

/*-------------------- 顶点并查集定义 --------------------*/
typedef Vertex ElementType; /* 默认元素可以用非负整数表示 */
typedef Vertex SetName;     /* 默认用根结点的下标作为集合名称 */
typedef ElementType SetType[MaxVertexNum]; /* 假设集合元素下标从0开始 */

void InitializeVSet( SetType S, int N )
{ /* 初始化并查集 */
    ElementType X;

    for ( X=0; X<N; X++ ) S[X] = -1;
}

void Union( SetType S, SetName Root1, SetName Root2 )
{ /* 这里默认Root1和Root2是不同集合的根结点 */
    /* 保证小集合并入大集合 */
    if ( S[Root2] < S[Root1] ) { /* 如果集合2比较大 */
        S[Root2] += S[Root1];     /* 集合1并入集合2  */
        S[Root1] = Root2;
    }
    else {                         /* 如果集合1比较大 */
        S[Root1] += S[Root2];     /* 集合2并入集合1  */
        S[Root2] = Root1;
    }
}

SetName Find( SetType S, ElementType X )
{ /* 默认集合元素全部初始化为-1 */
    if ( S[X] < 0 ) /* 找到集合的根 */
        return X;
    else
        return S[X] = Find( S, S[X] ); /* 路径压缩 */
}

bool CheckCycle( SetType VSet, Vertex V1, Vertex V2 )
{ /* 检查连接V1和V2的边是否在现有的最小生成树子集中构成回路 */
    Vertex Root1, Root2;

    Root1 = Find( VSet, V1 ); /* 得到V1所属的连通集名称 */
    Root2 = Find( VSet, V2 ); /* 得到V2所属的连通集名称 */

    if( Root1==Root2 ) /* 若V1和V2已经连通，则该边不能要 */
        return false;
    else { /* 否则该边可以被收集，同时将V1和V2并入同一连通集 */
        Union( VSet, Root1, Root2 );
        return true;
    }
}
/*-------------------- 并查集定义结束 --------------------*/

/*-------------------- 边的最小堆定义 --------------------*/
void PercDown( Edge ESet, int p, int N )
{
  /* 将N个元素的边数组中以ESet[p]为根的子堆调整为关于Weight的最小堆 */
    int Parent, Child;
    struct ENode X;

    X = ESet[p]; /* 取出根结点存放的值 */
    for( Parent=p; (Parent*2+1)<N; Parent=Child ) {
        Child = Parent * 2 + 1;
        if( (Child!=N-1) && (ESet[Child].Weight>ESet[Child+1].Weight) )
            Child++;  /* Child指向左右子结点的较小者 */
        if( X.Weight <= ESet[Child].Weight ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            ESet[Parent] = ESet[Child];
    }
    ESet[Parent] = X;
}

void InitializeESet( LGraph Graph, Edge ESet )
{ /* 将图的边存入数组ESet，并且初始化为最小堆 */
    Vertex V;
    PtrToAdjVNode W;
    int ECount;

    /* 将图的边存入数组ESet */
    ECount = 0;
    for ( V=0; V<Graph->Nv; V++ )
        for ( W=Graph->G[V].FirstEdge; W; W=W->Next )
            if ( V < W->AdjV ) { /* 避免重复录入无向图的边，只收V1<V2的边 */
                ESet[ECount].V1 = V;
                ESet[ECount].V2 = W->AdjV;
                ESet[ECount++].Weight = W->Weight;
            }
    /* 初始化为最小堆 */
    for ( ECount=Graph->Ne/2; ECount>=0; ECount-- )
        PercDown( ESet, ECount, Graph->Ne );
}

int GetEdge( Edge ESet, int CurrentSize )
{ /* 给定当前堆的大小CurrentSize，将当前最小边位置弹出并调整堆 */

    /* 将最小边与当前堆的最后一个位置的边交换 */
    Swap( &ESet[0], &ESet[CurrentSize-1]);
    /* 将剩下的边继续调整成最小堆 */
    PercDown( ESet, 0, CurrentSize-1 );

    return CurrentSize-1; /* 返回最小边所在位置 */
}
/*-------------------- 最小堆定义结束 --------------------*/


int Kruskal( LGraph Graph, LGraph MST )
{ /* 将最小生成树保存为邻接表存储的图MST，返回最小权重和 */
    WeightType TotalWeight;
    int ECount, NextEdge;
    SetType VSet; /* 顶点数组 */
    Edge ESet;    /* 边数组 */

    InitializeVSet( VSet, Graph->Nv ); /* 初始化顶点并查集 */
    ESet = (Edge)malloc( sizeof(struct ENode)*Graph->Ne );
    InitializeESet( Graph, ESet ); /* 初始化边的最小堆 */
    /* 创建包含所有顶点但没有边的图。注意用邻接表版本 */
    MST = CreateGraph(Graph->Nv);
    TotalWeight = 0; /* 初始化权重和     */
    ECount = 0;      /* 初始化收录的边数 */

    NextEdge = Graph->Ne; /* 原始边集的规模 */
    while ( ECount < Graph->Nv-1 ) {  /* 当收集的边不足以构成树时 */
        NextEdge = GetEdge( ESet, NextEdge ); /* 从边集中得到最小边的位置 */
        if (NextEdge < 0) /* 边集已空 */
            break;
        /* 如果该边的加入不构成回路，即两端结点不属于同一连通集 */
        if ( CheckCycle( VSet, ESet[NextEdge].V1, ESet[NextEdge].V2 )==true ) {
            /* 将该边插入MST */
            InsertEdge( MST, ESet+NextEdge );
            TotalWeight += ESet[NextEdge].Weight; /* 累计权重 */
            ECount++; /* 生成树中边数加1 */
        }
    }
    if ( ECount < Graph->Nv-1 )
        TotalWeight = -1; /* 设置错误标记，表示生成树不存在 */

    return TotalWeight;
}

8、拓扑排序

引入：

大学要学习几十门课，有些课需要先修其他课作为基础，才能选修。如何排出这些课选修的顺序？？

拓扑序：

如果图中从V到W有一条有向路径，并且V一定要排在W之前。满足此条件的顶点序列称为一个拓扑序。

获得一个拓扑序的过程就是拓扑排序。

AOV如果有合理的拓扑序，则必定是有向无环图。

需要拓扑排序的图：

需要拓扑的图

拓扑排序的可能结果：

拓扑排序结果

处理过程：

  1. 输出没有前驱结点（即入度为0）的顶点；
  2. 删除该顶点（后续顶点的入度-1）；
  3. 循环步骤1~2，直到拓扑图里无顶点。
void TopSort(){
    for(cnt = 0; cnt < V; cnt++){
        V = 未输出的入度为0的顶点;
        if( V 不存在){
            Error("图中有回路");
            break;
        }
        输出V，或者记录V的输出序号;
        for( V 的每个邻接点 W )
            Indegree[W]--;	//邻接点的入度-1
    }
}

时间复杂度主要看：怎么找为输出的入度为0的顶点。

可以随时把入度为0的结点，塞入一个容器里，栈或者队列。O(V + E)

void TopSort(){
    for( 图中的每个顶点 V ){
        if( Indegree[V] == 0 )
            Enqueue(V, Q);
    while(!IsEmpty(Q)){
        V = Dequeue(Q);
        输出V，或者记录V的输出序号;		cnt++;
        for( V 的每个邻接点 W )
            if(--Indequeue[W] == 0)	//如果去掉前驱结点，入度变为0，应该塞入队列。
                Enqueue(W, Q);
    }  
    if(cnt != V)
        Error("图中有回路");
}

/* 邻接表存储 - 拓扑排序算法 */

bool TopSort( LGraph Graph, Vertex TopOrder[] )
{ /* 对Graph进行拓扑排序,  TopOrder[]顺序存储排序后的顶点下标 */
    int Indegree[MaxVertexNum], cnt;
    Vertex V;
    PtrToAdjVNode W;
       Queue Q = CreateQueue( Graph->Nv );
 
    /* 初始化Indegree[] */
    for (V=0; V<Graph->Nv; V++)
        Indegree[V] = 0;
        
    /* 遍历图，得到Indegree[] */
    for (V=0; V<Graph->Nv; V++)
        for (W=Graph->G[V].FirstEdge; W; W=W->Next)
            Indegree[W->AdjV]++; /* 对有向边<V, W->AdjV>累计终点的入度 */
            
    /* 将所有入度为0的顶点入列 */
    for (V=0; V<Graph->Nv; V++)
        if ( Indegree[V]==0 )
            AddQ(Q, V);
            
    /* 下面进入拓扑排序 */ 
    cnt = 0; 
    while( !IsEmpty(Q) ){
        V = DeleteQ(Q); /* 弹出一个入度为0的顶点 */
        TopOrder[cnt++] = V; /* 将之存为结果序列的下一个元素 */
        /* 对V的每个邻接点W->AdjV */
        for ( W=Graph->G[V].FirstEdge; W; W=W->Next )
            if ( --Indegree[W->AdjV] == 0 )/* 若删除V使得W->AdjV入度为0 */
                AddQ(Q, W->AdjV); /* 则该顶点入列 */ 
    } /* while结束*/
    
    if ( cnt != Graph->Nv )
        return false; /* 说明图中有回路, 返回不成功标志 */ 
    else
        return true;
}

9、关键路径问题

AOE(Activity On Edge) 网络

  • 一般用于安排项目的工序

AOE网络

如何推导最早完成时间：

计算工期

初始化起点的最早完成时间为0。

计算方式：从起点开始推导。。。。

最早完成时间 = 前一个结点的最早完成时间 + 持续时间

如果有多条线路，取其中的最大值。

如何推导最晚完成时间：

计算最晚完成时间

初始化终点的最晚完成时间为其最早完成时间。

计算方式：从终点开始推导。。。。

最晚完成时间 = 后一个结点的最晚完成时间 - 持续时间

如果有多条线路，取其中最小值。

如何求机动时间：

机动时间 = Lastest[ j ] - Earliest[ i ] - C<i,j>

等于终点的最晚完成时间 - 起点的最早完成时间 - 边的持续时间。

例如：编号0到编号2的机动时间 = 6 - 0 - 4 = 2。

关键路径是啥：

由绝对不允许延误的活动组成的路径。

明々天
关注
专栏目录
数据结构学习日记（一）
weixin_46600208的博客
02-13 409
一， 1，数据元素是数据的基本单位，一个数据元素由若干数据项组成 2，数据结构：相互之间有关系的数据元素集合 ， 数据对象：相同性质的数据数据元素的集合 二， 1，逻辑结构 集合：各元素同属一个集合，无其他关系 线性结构：一对一关系，除了第一和最后，唯一前驱，唯一后继 树形结构：一对多关系 图状结构：多对多关系 2,物理结构 顺序存储：逻辑上相邻的元素存储在物理位置上也相邻的存储单元中。 链式存储：可以不相邻，用指针表示下一个数据元素的存储地址。 索引存储：建立附加的索引...
数据结构学习日记（五）
weixin_46600208的博客
02-17 167
一，静态链表 1）概念对比：单链表：包含数据元素和指向下一个节点的指针 静态链表：包含数据元素和下一个节点的数组下标（游标充当指针），用数组的方式实现链表，不能随机存取，只能从头结点开始依次往后查找，容量固定不可变。 2）基本操作：初始化，查找，插入，删除 二，顺序表格链表的对比： （1）逻辑结构：线性结构 （2）存储结构：顺序存储和链式存储 （3）基本操作： 创：（预分配一个空间，只需分配一个头结点） 销：（静态数组【lengeth=0】和动态数组【malloc和free】，free）
数据结构与算法学习日记：C语言中顺序表基本操作的实现
2402_83326934的博客
04-19 1482
在本篇博客中，我们将探讨使用C语言实现顺序表的基本操作。顺序表，也称为数组，是一种基础的数据结构，其中元素按顺序存储。我们将涵盖初始化列表、元素插入、删除、检索、列表反转等操作。
数据结构学习日记2024.1.15
lingxiao0519的博客
01-15 344
分析：连通分量是极大连通子图，可以用循环的方式，从图的顶点出发，调用递归的广度优先遍历函数，每成功执行完一次以循环变量值为顶点编号的DFS函数，代表一个连通分量所有顶点被完全遍历，计数变量自增。循环结束后，返回计数变量值，即为连通分量的个数。设计一个算法，求出无向图G的连通分量个数。
数据结构学习日记（三）
weixin_46600208的博客
02-15 482
一，单链表学习大纲 1）概念：每个结点除了存放数据元素外，还要存储指向下一个节点的指针， 不要求大片的连续空间，改变容量方便，无法逆向检索，要耗费一点空间存放指针。 2）实现方式：带头和不带头 3）基本操作： （1）插入：带头和不带头节点，指定节点的后插和前插 （2）删除：带头和不带头，指定节点的删除（特殊情况最后一个只能从表头开始） (3) 建立：尾插法（尾插法时候注意设置一个指向表位节点的指针） 和头插法（带头和不带头）注意重要应用：链表的逆置 (...
数据结构学习日记（预）
ABazingaE的博客
01-17 192
寒假匆匆到来，为了督促和帮助自己学习，打算自学数据结构，每天会在这里写下学习的心得体会！
数据结构学习日记----1
James__qiu的博客
02-10 314
数据结构学习日记----1 ▪ 数据结构是学习计算机科学的基础，它能让我们学习到一些计算机底层的东西，能够帮助我们更好的去理解和应用计算机。 ▪ 历史来源：1968年美国的高德纳在《计算机程序设计艺术》一书中提出。 A.什么是数据？ 数据是描述客观事物的符号，是计算机中可以操作的对象。 数据，数据对象，数据元素，数据项的关系可有下面的导图直观的看到。 B.什么是数据结构？ 数据结构是相互之间存在...
数据结构与算法学习日记：C语言中链表的表示和实现
2402_83326934的博客
04-21 1563
链表是一种常见的线性数据结构，由一系列节点（node）组成，每个节点包含两部分：数据域和指针域。数据域存储节点的数据，指针域指向下一个节点，从而将节点连接起来形成链式结构。链表可以分为多种类型，包括单链表、双链表和循环链表等。单链表：每个节点只包含一个指针，指向下一个节点，最后一个节点的指针指向 NULL。双链表：每个节点包含两个指针，分别指向前驱节点和后继节点，使得节点可以双向遍历。循环链表：最后一个节点的指针指向第一个节点，形成一个闭环。
2.1数据结构与算法学习日记
weixin_64589886的博客
02-02 2662
Byteburg市东边的建筑都是以旧结构形式建造的:建筑互相紧挨着,之间没有空间.它们共同形成了一条长长的,从东向西延伸的建筑物链(建筑物的高度不一).Byteburg市的市长Byteasar,决定将这个建筑物链的一侧用海报覆盖住.并且想用最少的海报数量,海报是矩形的.海报与海报之间不能重叠,但是可以相互挨着(即它们具有公共边),每一个海报都必须贴近墙并且建筑物链的整个一侧必须被覆盖(意思是:海报需要将一侧全部覆盖,并且不能超出建筑物链)
数据结构与算法学习日记【2】
horizon_157 Blog
04-27 178
二叉树的遍历二叉树图遍历说明前序遍历中序遍历后序遍历说明二叉树的三种遍历前序遍历中序遍历后序遍历 二叉树图 遍历说明 前序遍历 前序遍历是三种遍历中最为简单的一种遍历，只需从头往下遍历完左子树然后再遍历右子树即可。 中序遍历 找到左子树的中间结点，遍历完左子树再遍历右子树，然后再寻找右子树的中间结点同理遍历。 后序遍历 后序遍历即为前序遍历的反方向，从左子树的底部往上遍历，然后再遍历右子树 说明 所有遍历都是先左子树再右子树！！！ 二叉树的三种遍历 前序遍历 遍历结果：ABDGHICEJF 遍历过程⬇️
vue学习日记19：记事本-组件版
03-26
"vue学习日记19：记事本-组件版"是一个关于如何利用Vue.js创建一个功能丰富的记事本组件的实例教程。在这个项目中，我们将深入探讨Vue组件的基本概念、组件的生命周期、状态管理和事件通信。 首先，Vue组件是Vue...
C语言+数据结构课程设计：日记管理系统实验报告.pdf
10-14
这个实验报告详细阐述了一个基于C语言和数据结构的日记管理系统的设计与实现，涵盖了用户认证、日记存储、查询和删除等多个核心功能，同时强调了数据的安全性和界面的友好性，是学习C语言和数据结构应用的典型案例。
21_动态规划与数据结构结合
刘炫320的博客
09-11 488
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
数据结构 1
2401_83575662的博客
09-14 442
算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为 输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《程序员代码面试指南》。4.算法的效率衡量一个算法的好坏，要从它的程序的时间复杂度和空间复杂度两方面来分析。时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。5.时间复杂度。
数据结构（红黑树）
qq_63126439的博客
09-08 393
红黑树是一种自平衡的二叉查找树，是计算机科学中用到的一种数据结构。1972年出现，当时被称之为平衡二叉B树。后来，1978年被修改为如今的"红黑树"它是一种特殊的二叉查找树，红黑树的每一个节点上都有存储位表示节点的颜色每一个节点可以是红或者黑;红黑树不是高度平衡的，它的平衡是通过"红黑规则"进行实现的。
【JavaScript】数据结构之字典 & 哈希表
最新发布
票票的博客
09-14 450
数据结构之字典和哈希表
数据结构 - 链表
kaneki_lh的博客
09-11 433
listnode;/* 双向链表结构体 */}dlinklist;
树、二叉树、特殊的二叉树（堆）、霍夫曼树
qq_73643693的博客
09-14 873
数据结构与算法之树，该篇文章说明了树的一些用法和基本概念
从0开始的算法（数据结构和算法）基础（十）
Solidao的博客
09-12 848
分治的字面意思是分而治之，将问题进行分化，从而进行处理，最后将结果进行合并。尽量的将问题分的不可以再分，分到和操作系统里面的原语是一样的，用较为多空间进行多线程的并行，节省时间运行。递归调用可能会导致较大的递归开销，特别是在递归深度较大的情况下，可能会导致栈溢出。在某些情况下，分治方法可能会导致对同一子问题的重复计算，从而降低效率。例如，在动态规划问题中，使用简单的分治方法可能会导致大量重复计算。
C语言学习日记：从入门到精通
学习日记的其余部分可能涵盖了C语言的基础知识，例如变量、数据类型、控制结构、函数、指针、内存管理等概念。通过每天的学习记录，作者逐步深入讲解了这些主题，这对于初学者来说是一种很好的学习模式，因为它提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值