数据结构和算法——用C语言实现所有图状结构及相关算法

已于 2023-12-02 18:38:55 修改
阅读量524 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 c语言 图
于 2023-10-31 14:27:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45295475/article/details/129909342
版权

文章目录

前言

本文所有代码均在仓库中，这是一个完整的由纯C语言实现的可以存储任意类型元素的数据结构的工程项目。

在这里插入图片描述

  • 首先是极好的工程意识，该项目是一个中大型的CMake项目，结构目录清晰，通过这个项目可以遇见许多工程问题并且可以培养自己的工程意识。
  • 其次是优秀的封装性（每个数据结构的头文件中只暴漏少量的信息），以及优秀的代码风格和全面的注释，通过这个项目可以提升自己的封装技巧：

在这里插入图片描述

在这里插入图片描述

最后也是最重要的一点，数据结构的通用性和舒适的体验感，下面以平衡二叉树为例：

  • 第一步：要想使用平衡二叉树，只需要引入其的头文件：
#include "tree-structure/balanced-binary-tree/BalancedBinaryTree.h"
  • 第二步：定义自己任意类型的数据，并构造插入数据（以一个自定义的结构体为例）：
#include "tree-structure/balanced-binary-tree/BalancedBinaryTree.h"

int dataCompare(void *, void *);

typedef struct People {
    char *name;
    int age;
} *People;

int main(int argc, char **argv) {
    struct People dataList[] = {
            {"张三", 15},
            {"李四", 3},
            {"王五", 7},
            {"赵六", 10},
            {"田七", 9},
            {"周八", 8},
    };
    BalancedBinaryTree tree = balancedBinaryTreeConstructor(NULL, 0, dataCompare);
    for (int i = 0; i < 6; ++i) {
        balancedBinaryTreeInsert(&tree, dataList + i, dataCompare);
    }
    return 0;
}

/**
 * 根据人的年龄比较
 */
int dataCompare(void *data1, void *data2) {
    int sub = ((People) data1)->age - ((People) data2)->age;
    if (sub > 0) {
        return 1;
    } else if (sub < 0) {
        return -1;
    } else {
        return 0;
    }
}
  • 第三步：打印一下平衡二叉树：
#include "tree-structure/balanced-binary-tree/BalancedBinaryTree.h"

int dataCompare(void *, void *);

void dataPrint(void *);

typedef struct People {
    char *name;
    int age;
} *People;

int main(int argc, char **argv) {
    struct People dataList[] = {
            {"张三", 15},
            {"李四", 3},
            {"王五", 7},
            {"赵六", 10},
            {"田七", 9},
            {"周八", 8},
    };
    BalancedBinaryTree tree = balancedBinaryTreeConstructor(NULL, 0, dataCompare);
    for (int i = 0; i < 6; ++i) {
        balancedBinaryTreeInsert(&tree, dataList + i, dataCompare);
        balancedBinaryTreePrint(tree, dataPrint);
        printf("-------------\n");
    }
    return 0;
}

/**
 * 根据人的年龄比较
 */
int dataCompare(void *data1, void *data2) {
    int sub = ((People) data1)->age - ((People) data2)->age;
    if (sub > 0) {
        return 1;
    } else if (sub < 0) {
        return -1;
    } else {
        return 0;
    }
}

/**
 * 打印人的年龄
 * @param data
 */
void dataPrint(void *data) {
    People people = (People) data;
    printf("%d", people->age);
}

打印的结果如下：

在这里插入图片描述
最后期待大佬们的点赞。

图的基本概念

图 G G G由顶点集 V V V和边集 E E E组成，记为：
G = ( V , E ) G=(V,E) G=(V,E)
若 V = { v 1 , v 2 , … , v n } V=\{v_1,v_2,\dots,v_n\} V={v1​,v2​,…,vn​}则用 ∣ V ∣ |V| ∣V∣表示图 G G G中顶点的个数，也称为图 G G G的阶；若 E = { ( a , b ) ∣ a ∈ V , b ∈ V } E=\{(a,b)|a\in V,b\in V\} E={(a,b)∣a∈V,b∈V}则用 ∣ E ∣ |E| ∣E∣表示图 G G G中边的条数。不存在空图，即一个图的点集是非空的。图的分类如下：

  • 无向图：若 E E E为无向边（简称边）的有限集合，则 G G G为无向图
    • 0 < ∣ E ∣ < ∣ V ∣ ( ∣ V ∣ − 1 ) 2 0<|E|<\frac{|V|(|V|-1)}{2} 0<∣E∣<2∣V∣(∣V∣−1)​
  • 有向图：若 E E E为有向边（简称弧）的有限集合，则 G G G为有向图
    • 0 < ∣ E ∣ < ∣ V ∣ ( ∣ V ∣ − 1 ) 0<|E|<|V|(|V|-1) 0<∣E∣<∣V∣(∣V∣−1)
  • 简单图和多重图：如果一个图不存在重复边和顶点到自身的边，那么称图为简单图，否则称为多重图

图的相关术语如下：

  • 顶点的度、入度和出度：

    • 对于无向图而言：
      • 顶点 v v v的度是指依附于该顶点的边的数目，记为 T D ( v ) TD(v) TD(v)
      • ∑ i = 1 n T D ( v i ) = 2 ∣ E ∣ \sum_{i=1}^n TD(v_i)=2|E| i=1∑n​TD(vi​)=2∣E∣
    • 对于有向图而言：
      • 入度是指以顶点 v v v为终点的弧的数目，记为 I D ( v ) ID(v) ID(v)
      • 出度是以顶点为起点的弧的数目，记为 O D ( v ) OD(v) OD(v)
      • 顶点 v v v的度等于其入度和出度之和
      • ∑ i = 1 n I D ( v i ) = ∑ i = 1 n O D ( v i ) = ∣ E ∣ \sum_{i=1}^n ID(v_i)=\sum_{i=1}^n OD(v_i)=|E| i=1∑n​ID(vi​)=i=1∑n​OD(vi​)=∣E∣

  • 路径和回路：

    • 从一个顶点到另一个顶点之间经过的所有顶点的序列称为路径，顶点不重复的路径称为简单路径
    • 起点和终点为同一个顶点的路径称为回路，除第一个顶点外，其余顶点不重复的回路称为简单回路

  • 路径长度：路径上边的数目称为路径长度。两个顶点之间的最短路径长度称为距离，路径不存在则距离为无穷

  • 子图和生成子图：

    • 顶点集和边集分别是某图顶点集和边集子集的图称为某图的子图
    • 包含某图所有顶点的子图称为生成子图

  • 连通图和连通分量：

    • 在无向图中，两个不同顶点之间存在至少一条路径，则称这两个顶点是连通的。若图中任意两个顶点都是连通的，则称该图为连通图，否则称为非连通图
    • 无向图中的极大连通子图称为连通分量
    • 若图是连通的，则 ∣ E ∣ ≥ ∣ V ∣ − 1 |E|\geq|V|-1 ∣E∣≥∣V∣−1
    • 若图是非连通的，则 ∣ E ∣ ≤ C ∣ V ∣ − 1 2 |E|\leq C^2_{|V|-1} ∣E∣≤C∣V∣−12​

  • 强连通图和强连通分量：

    • 在有向图中，两个不同顶点之间存在至少一条路径，则称这两个顶点是强连通的。若图中任意两个顶点都是连通的，则称该图为强连通图，否则称为非强连通图
    • 有向图中的极大连通子图称为强连通分量
    • 若图是连通的，则 ∣ E ∣ ≥ ∣ V ∣ |E|\geq|V| ∣E∣≥∣V∣

  • 完全图：任意两个顶点之间都有一条边相连的图称为完全图

    • 对于无向图而言， 0 ≤ ∣ E ∣ ≤ C ∣ V ∣ 2 0\leq|E|\leq C^2_{|V|} 0≤∣E∣≤C∣V∣2​
    • 对于有向图而言， 0 ≤ ∣ E ∣ ≤ 2 C ∣ V ∣ 2 0\leq |E|\leq 2C^2_{|V|} 0≤∣E∣≤2C∣V∣2​

  • 生成树和生成森林：

    • 在连通图中，包含所有顶点的极小连通子图称为连通图的生成树
    • 在非连通图中，连通分量的生成树称为非连通图的生成森林

  • 边的权、网和带权路径长度：

    • 为每条边标记的具有一定意义的数值称为边的权
    • 边上带有权值的图称为网
    • 一条路径上所有边的权值之和称为该路径的带权路径长度

  • 树和有向树：

    • 不存在回路且连通的无向图称为树
    • 一个顶点的入度为零，其余顶点的入度均为一的有向图称为有向树

图的存储方式

图一般有以下几种存储方式：

  • 邻接矩阵法
  • 邻接表法
  • 十字链表法
  • 邻接多重表

邻接矩阵

邻接矩阵法用一个一维数组存储图中的顶点信息，用一个二维数组存储图中边的信息（即顶点之间的邻接关系），这个二维数组就是邻接矩阵。邻接矩阵法适合存储稠密图。

在这里插入图片描述

struct AdjacentMatrixGraph {
    void **vertexList;
    int **edgeMatrix;
    int vertexCount;
    int edgeCount;
    int size;

    int (*compare)(void *, void *);
};

对于图而言：

  • e d g e M a t r i x [ i ] [ j ] = { 1 若 ( v i , v j ) 或 ( v j , v i ) 是 G 的边 0 若 ( v i , v j ) 或 ( v j , v i ) 不是 G 的边 edgeMatrix[i][j]= \begin{cases} 1&若(v_i,v_j)或(v_j,v_i)是G的边\\ 0&若(v_i,v_j)或(v_j,v_i)不是G的边 \end{cases} edgeMatrix[i][j]={10​若(vi​,vj​)或(vj​,vi​)是G的边若(vi​,vj​)或(vj​,vi​)不是G的边​
  • 无向图的邻接矩阵是一个对称矩阵，因此在存储时可以使用压缩矩阵存储。

对于网而言：

  • e d g e M a t r i x [ i ] [ j ] = { 权值 若 ( v i , v j ) 或 ( v j , v i ) 是 G 的边 0 或 ∞ 若 ( v i , v j ) 或 ( v j , v i ) 不是 G 的边 edgeMatrix[i][j]= \begin{cases} 权值&若(v_i,v_j)或(v_j,v_i)是G的边\\ 0或\infty&若(v_i,v_j)或(v_j,v_i)不是G的边 \end{cases} edgeMatrix[i][j]={权值0或∞​若(vi​,vj​)或(vj​,vi​)是G的边若(vi​,vj​)或(vj​,vi​)不是G的边​

邻接表

邻接表法为每个顶点建立一个单链表，这个链表中的结点表示依附于该顶点的边，这个单链表称为顶点的边表。邻接表法适合存储稀疏图。

在这里插入图片描述

typedef struct Edge {
    int weight;
    int vertexIndex;
    struct Edge *next;
} *Edge;

typedef struct Vertex {
    void *data;
    Edge firstEdge;
} *Vertex, *VertexList;

struct AdjacentListGraph {
    VertexList *vertexList;
    int vertexCount;
    int edgeCount;
    int size;

    int (*compare)(void *, void *);
};

十字链表

十字链表法是有向图的一种链式存储结构，一个十字链表可以唯一确定一个图。

在这里插入图片描述

typedef struct Arc {
    void *data;
    int tailVex; //弧头顶点位置
    int headVex; //弧尾顶点位置
    int headLink; //弧头相同的下一条弧
    int tailLink; //弧尾相同的下一条弧
}Arc;

typedef struct Vertex {
    void *data;
    Arc *firstIn; //以该顶点为弧头的第一个弧顶点
    Arc *firstOut; //以该顶点为为弧尾的第一个弧顶点
} *VexList;

struct AcrossLinkerGraph {
    VexList vexList;
    int vexNum;
    int arcNum;
};

临接多重表

邻接多重表是无向图的一种链式存储结构。

在这里插入图片描述

typedef struct Edge {
    bool mark;  //是否被搜搜过
    int iVex;   //该边依附的一个顶点位置
    int jVex;   //该边依附的另一个顶点位置
    int iLink;  //下一个依附顶点iVex的边
    int jLink;  //下一个依附顶点jVex的边
} Edge;

typedef struct Vertex {
    void *data;
    Edge *firstEdge; //第一个依附该顶点的边
} Vertex, *VertexList;

struct AMLGraph {
    VertexList vertexList;
    int vertexNum;
    int edgeNum;
};

图的遍历

图的遍历是指从图中的某一顶点出发，按照某种搜索方法沿着图中的边对图中的所有顶点访问一次且仅访问一次的过程。图的遍历方式主要有以下两种：

  • 广度优先搜索（BFS）
  • 深度优先搜索（DFS）

广度优先搜索

算法思想

  • 从图的某一顶点出发，依次访问该顶点的所有邻接顶点；
  • 再从这些访问过的邻接顶点出发，依次访问它们的邻接顶点，直到图中所有顶点都被访问为止；
  • 若图中还有顶点尚未被访问，则选择一个尚未被访问的顶点重复上述过程。
void BFS(AdjacentListGraph graph, bool isVisited[], LinkedQueue queue, LinkedQueue BFSDataQueue) {
    while (!linkedQueueIsEmpty(queue)) {
        Vertex vertex = linkedQueueDeQueue(queue);
        linkedQueueEnQueue(BFSDataQueue, vertex->data);
        isVisited[getVertexIndex(graph, vertex->data) - 1] = true;
        for (Vertex j = firstVertex(graph, vertex->data); j != NULL; j = nextVertex(graph, vertex->data, j->data)) {
            if (!isVisited[getVertexIndex(graph, j->data) - 1]) {
                linkedQueueEnQueue(queue, j);
            }
        }
    }
}

/**
 * 广度优先遍历
 * @param graph
 * @param BFSDataQueue
 */
void BFSTraverse(AdjacentListGraph graph, void *data, LinkedQueue BFSDataQueue) {
    bool *isVisited = calloc(graph->vertexCount, sizeof(bool));
    LinkedQueue queue = linkedQueueConstructor();
    linkedQueueEnQueue(queue, graph->vertexList[getVertexIndex(graph, data) - 1]);
    BFS(graph, isVisited, queue, BFSDataQueue);
    for (int i = 1; i <= graph->vertexCount; ++i) {
        if (!isVisited[i - 1]) {
            BFS(graph, isVisited, queue, BFSDataQueue);
        }
    }
}

深度优先搜索

算法思想：

  • 从图的某一顶点出发，访问它的任一邻接顶点；再从邻接顶点出发，访问邻接顶点的任一邻接顶点；如此往复直到访问到一个所有邻接顶点都被访问的顶点为止；
  • 接着回退一步，看看前一次访问的顶点是否还有其它没有被访问的邻接顶点；如果有，则访问此邻接顶点，之后再进行前述过程；如果没有，则再回退一步，重复上述过程，直到连通图中所顶点都被访问过为止。
void DFS(AdjacentListGraph graph, int vertexIndex, bool isVisited[], LinkedQueue DFSDataQueue) {
    Vertex vertex = graph->vertexList[vertexIndex - 1];
    linkedQueueEnQueue(DFSDataQueue, vertex->data);
    isVisited[vertexIndex - 1] = true;
    for (Vertex j = firstVertex(graph, vertex->data); j != NULL; j = nextVertex(graph, vertex->data, j->data)) {
        int index = getVertexIndex(graph, j->data);
        if (!isVisited[index - 1]) {
            DFS(graph, index, isVisited, DFSDataQueue);
        }
    }
}

/**
 * 深度优先遍历
 * @param graph
 * @param data
 * @param DFSDataQueue
 */
void DFSTraverse(AdjacentListGraph graph, void *data, LinkedQueue DFSDataQueue) {
    bool *isVisited = calloc(graph->vertexCount, sizeof(bool));
    int index = getVertexIndex(graph, data);
    DFS(graph, index, isVisited, DFSDataQueue);
    for (int i = 1; i <= graph->vertexCount; ++i) {
        if (!isVisited[i - 1]) {
            DFS(graph, i, isVisited, DFSDataQueue);
        }
    }
}

最小生成树

对于一个带权连通无向图 G G G，生成树不同，每棵树的权值也可能不同，若 T T T为权值最小的生成树，则 T T T称为 G G G的最小生成树（MST）。最小生成树的性质如下：

  • 如果 G G G中有权值相等的边，则最小生成树不是唯一的，若 G G G的边数比顶点数少一，则 G G G的生成树就是它本身。
  • 最小生成树的边的权值是唯一的，且是最小的。
  • 最小生成树的边数为顶点数减一。
  • U U U是 V V V的一个子集，若 ( u , v ) (u,v) (u,v)是一条具有最小权值的边，其中 u ∈ U ， v ∈ V − U u∈U，v∈V-U u∈U，v∈V−U，则必存在一棵包含 ( u , v ) (u,v) (u,v)的最小生成树。

普里姆算法（Prim）

算法思想：

  • 初始时从图中选择一个顶点加入树 T T T，此时树中只有这一个顶点；
  • 之后选择一个与当前 T T T中顶点集合距离最近的顶点，并将该顶点和相应的边加入 T T T；
  • 以此类推，直到图中所有的顶点都加入 T T T，得到的 T T T就是最小生成树。

时间复杂度： O ( ∣ V ∣ 2 ) O(|V|^2) O(∣V∣2)

/**
 * Prim算法
 * @param graph
 * @return
 */
AdjacentListGraph Prim(AdjacentListGraph graph) {
    AdjacentListGraph MST = adjacentListGraphConstructor(graph->vertexCount, graph->compare);
    //是否加入最小生成树
    bool isJoin[graph->vertexCount];
    //路径长度
    int distance[graph->vertexCount];
    //路径前驱
    int path[graph->vertexCount];
    for (int i = 0; i < graph->vertexCount; ++i) {
        isJoin[i] = false;
        distance[i] = INFINITY;
        path[i] = -1;
    }
    while (MST->size != graph->vertexCount) {
        int fromIndex = -1, toIndex = -1, minDistance = 0;
        if (MST->vertexCount == 0) {
            toIndex = 1;
        } else {
            for (int i = 1; i <= graph->vertexCount; ++i) {
                if (isJoin[i - 1] == false && distance[i - 1] < minDistance) {
                    fromIndex = path[i - 1];
                    toIndex = i;
                    minDistance = distance[i - 1];
                }
            }
            if (toIndex == -1) {
                break;
            }
        }
        isJoin[toIndex - 1] = true;
        distance[toIndex - 1] = minDistance;
        path[toIndex - 1] = fromIndex;
        for (Edge edge = graph->vertexList[toIndex - 1]->firstEdge; edge != NULL; edge = edge->next) {
            if (edge->weight < distance[edge->vertexIndex - 1]) {
                distance[edge->vertexIndex - 1] = edge->weight;
                path[edge->vertexIndex - 1] = toIndex;
            }
        }
        insertVertex(MST, graph->vertexList[toIndex - 1]->data);
        MST->vertexCount++;
        addEdge(MST, graph->vertexList[fromIndex - 1]->data, graph->vertexList[toIndex - 1]->data);
        MST->edgeCount++;
        fromIndex = -1;
        toIndex = -1;
        minDistance = 0;
    }
    return MST;
}

克鲁斯卡尔算法（Kruskal）

算法思想：

  • 将所有顶点都加入树 T T T，但是不加入边信息；
  • 然后在图中寻找权值最小的边，若该边依附的顶点落在树 T T T的顶点上，且不形成环，那么就把该边加入到树 T T T中，否则就舍弃该边；
  • 依次类推，直至 T T T中所有顶点都连通。
/**
 * 克鲁斯卡尔算法
 * @param graph 
 * @return 
 */
AdjacentListGraph Kruskal(AdjacentListGraph graph) {
    AdjacentListGraph MST = adjacentListGraphConstructor(graph->vertexCount, graph->compare);
    PriorityQueue queue = priorityQueueConstructor(graph->compare);
    DisjointSet set = disjointSetConstructor(graph->vertexCount, graph->compare);
    for (int i = 1; i <= graph->vertexCount; ++i) {
        Vertex vertex = graph->vertexList[i - 1];
        disjointSetInsert(set, vertex->data);
        insertVertex(MST, vertex->data);
        for (Edge edge = graph->vertexList[i - 1]->firstEdge; edge != NULL; edge = edge->next) {
            int *tuple = calloc(3, sizeof(int));
            tuple[0] = i;
            tuple[1] = edge->vertexIndex;
            tuple[2] = edge->weight;
            priorityQueueEnQueue(queue, tuple);
        }
    }
    while (!priorityQueueIsEmpty(queue)) {
        int *tuple = priorityQueueDeQueue(queue);
        Vertex fromVertex = graph->vertexList[tuple[0] - 1];
        Vertex toVertex = graph->vertexList[tuple[1] - 1];
        int weight = tuple[2];
        if (graph->compare(disjointSetFind(set, fromVertex->data), disjointSetFind(set, toVertex->data)) != 0) {
            addEdge(MST, fromVertex->data, toVertex->data);
            setWeight(MST, fromVertex->data, toVertex->data, weight);
            disjointSetUnion(set, fromVertex, toVertex);
        }
    }
    return MST;
}

最短路径

在图中，把一个顶点到另一个顶点的一条路径所经过边上的权值 （无权图视为权为 1 1 1）之和称为该路径的带权路径长度，带权路径长度最短的路径称为最短路径。两点之间的最短路径一定包含路径上其它顶点之间的最短路径。其中：

  • 无权图的单源最短路径问题可由 B F S BFS BFS算法和 D i j k s t r a Dijkstra Dijkstra算法解决
  • 带权图的单源最短路径问题可由 D i j k s t r a Dijkstra Dijkstra算法解决
  • 带权图和无权图的各顶点最短路径问题可由 F l o y d Floyd Floyd算法解决

BFS求最短路径

/**
 * BFS求无权图最短路径
 * @param graph
 * @param startVertex
 * @param endVertex
 * @param stack
 */
void adjacentListGraphBFSMinPath(AdjacentListGraph graph, void *startVertex, void *endVertex, SequenceStack stack) {
    //起始顶点到各个顶点的最短路径长度
    int distance[graph->vertexCount];
    //最短路径从哪个顶点过来
    int path[graph->vertexCount];
    bool isVisited[graph->vertexCount];
    for (int i = 0; i < graph->vertexCount; ++i) {
        distance[i] = INFINITY;
        path[i] = -1;
        isVisited[i] = false;
    }
    int startIndex = getVertexIndex(graph, startVertex);
    LinkedQueue queue = linkedQueueConstructor();
    distance[startIndex - 1] = 0;
    isVisited[startIndex - 1] = true;
    linkedQueueEnQueue(queue, startVertex);
    while (linkedQueueIsEmpty(queue)) {
        Vertex vertex = linkedQueueDeQueue(queue);
        int fromIndex = getVertexIndex(graph, vertex->data);
        for (Vertex toVertex = firstVertex(graph, vertex->data); toVertex != NULL; toVertex = nextVertex(graph, vertex->data, toVertex->data)) {
            int toIndex = getVertexIndex(graph, toVertex->data);
            if (!isVisited[toIndex - 1]) {
                distance[toIndex - 1] = distance[fromIndex - 1] + 1;
                path[toIndex - 1] = fromIndex;
                isVisited[toIndex - 1] = true;
                linkedQueueEnQueue(queue, toVertex);
            }
        }
    }
    int endIndex = getVertexIndex(graph, endVertex);
    while (path[endIndex - 1] != -1) {
        sequenceStackPush(stack, graph->vertexList[endIndex - 1]);
        endIndex = path[endIndex - 1];
    }
}

迪杰斯特拉算法（Dijkstra）

算法思想：

  • 首先找出源顶点到达其它顶点的直达路径，不能直达记为无穷大。
  • 从这些路径中挑选一条长度最短的路径。并将该顶点加入集合S。
  • 对其余的路径进行调整，若能经过找到的最短路径到达其它顶点并且该路径之和比直达路径小，那么就是用该路径替代原来的直达路径。并将该顶点加入集合S。
  • 之后重复上述步骤直到所有顶点都加入到S集合。

缺陷：不适用于负权值带权图

/**
 * 迪杰斯特拉算法
 * @param graph
 * @param startVertex
 * @param endVertex
 * @param stack
 */
void Dijkstra(AdjacentListGraph graph, void *startVertex, void *endVertex, SequenceStack stack) {
    int findCount = 0;
    //标记各顶点是否找到最短路径
    bool isFind[graph->vertexCount];
    //最短路径长度
    int distance[graph->vertexCount];
    //路径前驱
    int path[graph->vertexCount];
    for (int i = 0; i < graph->vertexCount; ++i) {
        isFind[i] = false;
        distance[i] = INFINITY;
        path[i] = -1;
    }
    while (findCount != graph->vertexCount) {
        int fromIndex = -1, toIndex = -1, minDistance = 0;
        if (findCount == 0) {
            toIndex = getVertexIndex(graph, startVertex);
        } else {
            for (int i = 1; i <= graph->vertexCount; ++i) {
                if (isFind[i - 1] == false && distance[i - 1] < minDistance) {
                    fromIndex = path[i - 1];
                    toIndex = i;
                    minDistance = distance[i - 1];
                }
            }
            if (toIndex == -1) {
                break;
            }
        }
        isFind[toIndex - 1] = true;
        distance[toIndex - 1] = minDistance;
        path[toIndex - 1] = fromIndex;
        for (Edge edge = graph->vertexList[toIndex - 1]->firstEdge; edge != NULL; edge = edge->next) {
            if (distance[toIndex - 1] + edge->weight < distance[edge->vertexIndex - 1]) {
                distance[edge->vertexIndex - 1] = distance[toIndex - 1] + edge->weight;
                path[edge->vertexIndex - 1] = toIndex;
            }
        }
        findCount++;
        fromIndex = -1;
        toIndex = -1;
        minDistance = 0;
    }
    int minPath = getVertexIndex(graph, endVertex);
    while (path[minPath - 1] != -1) {
        sequenceStackPush(stack, graph->vertexList[minPath - 1]);
        minPath = path[minPath - 1];
    }
}

弗洛伊德算法（Floyd）

  • 逐个顶点试探，选出一条路径长度最短的。
  • 初始时用一个矩阵存储各个顶点之间的距离，如果存在直达路径则记录直达路径，否则记录为无穷大。
  • 逐步在原直接路径中增加中间顶点，若加入中间顶点后路径变短，则修改矩阵中的值，否则矩阵中的值不变。
  • 所有顶点试探完毕，算法结束。

有向无环图

若一个有向图中不存在环，则称该图为有向无环图，简称DAG图。若用DAG图表示一个工程的各个子工程及其相互制约的关系：

  • 其中以顶点表示活动，弧表示活动之间的优先制约关系。则将这样的图称为AOV网。AOV网的特点如下：

    • 若从A到B有一条有向路径，则A是B的前驱，B是A的后继。
    • 若AB是网中的有向边，则A是B的直接前驱，B是A的直接后继。

  • 其中以弧表示活动，顶点表示活动的开始和结束事件。则将这样的图称为AOE网。AOE网的性质如下：

    • 只有在某顶点所代表的事件发生后，从该顶点出发的各有向边所代表的活动才能开始。
    • 只有在进入某顶点的各有向边所代表的活动都已结束时，该顶点所代表的事件才能发生。

AOV网的拓扑结构

在AOV网中，我们将全部活动排列成一个线性序列，使得若AOV网中有边AB存在，则在这个序列中，A一定排在B的前面，具有这种性质的线性序列称为拓扑有序序列。即做事的先后顺序。用于求解拓扑序列的算法称为拓扑排序算法，拓扑排序算法可以用于检测图中是否含有环：如果拓扑序列中含有所有图中的结点，那么该图就没有环，否则就含有环。

拓扑排序

拓扑排序的算法思想如下：

  • 在AOV网中选一个没有前驱的顶点，然后从图网中删除该顶点以及以这个顶点为起点的边。
  • 重复上面的步骤，直到网为空或网中不存在无前驱的顶点为止。
/**
 * 拓扑排序
 * @param graph
 * @param queue
 */
void topologicalSort(AdjacentListGraph graph, LinkedQueue queue) {
    SequenceStack stack = sequenceStackConstructor(graph->vertexCount);
    int inDegreeList[graph->vertexCount];
    for (int i = 1; i <= graph->vertexCount; ++i) {
        inDegreeList[i - 1] = getInDegree(graph, graph->vertexList[i - 1]->data);
        if (inDegreeList[i - 1] == 0) {
            sequenceStackPush(stack, graph->vertexList[i - 1]);
        }
    }
    while (!sequenceStackIsEmpty(stack)) {
        Vertex vertex = sequenceStackPop(stack);
        linkedQueueEnQueue(queue, vertex->data);
        for (Edge edge = vertex->firstEdge; edge != NULL; edge = edge->next) {
            if (--inDegreeList[edge->vertexIndex - 1] == 0) {
                sequenceStackPush(stack, graph->vertexList[edge->vertexIndex - 1]);
            }
        }
    }
}

逆拓扑排序

逆拓扑排序的算法思想如下：

  • 在AOV网中选一个没有后继的顶点，然后从图网中删除该顶点以及以这个顶点为终点的边。
  • 重复上面的步骤，直到网为空或网中不存在无后继的顶点为止。
void DFS(AdjacentListGraph graph, int index, int isVisited[], LinkedQueue queue) {
    isVisited[index - 1] += 2;
    Vertex vertex = graph->vertexList[index - 1];
    for (Edge edge = vertex->firstEdge; edge != NULL; edge = edge->next) {
        if (isVisited[edge->vertexIndex - 1] == 0) {
            DFS(graph, edge->vertexIndex, isVisited, queue);
        }
        if (isVisited[edge->vertexIndex - 1] == 2) {
            throw Error(CYCLIC_GRAPH_ERROR, "图中含有环，逆拓扑排序失败");
        }
    }
    isVisited[index - 1]--;
    linkedQueueEnQueue(queue, vertex->data);
}

/**
 * 深度优先算法求逆拓扑排序
 * @param graph
 * @param queue
 */
void DFSInTopologicalSort(AdjacentListGraph graph, LinkedQueue queue) {
    int *isVisited = calloc(graph->vertexCount, sizeof(bool));
    for (int i = 1; i <= graph->vertexCount; ++i) {
        if (isVisited[i - 1] == 0) {
            DFS(graph, i, isVisited, queue);
        }
    }
}

AOE网的关键路径

在AOE网中，入度为零的顶点称为源点，出度为零的顶点称为汇点，关键路径是指从源点到汇点路径长度最长的路径。关键路径上的活动称为关键活动。完成整个工程最短的时间就是关键路径的长度。

亻乍屯页女子白勺
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言数字图像处理进阶---1 Photoshop图层算法
Trent1985的专栏
08-12 2561
前言 本专栏为《零基础C语言数字图像处理利器》的进阶版，对于没有任何C语言基础的同学们，在学习了《零基础C语言数字图像处理利器》之后，已经对C语言进行图像处理有了初步的认识和入门，如果想要进一步向图像算法工程师迈进，那么，本专栏将从图像滤镜特效方面帮助大家，真正的做一些可以工程应用的滤镜特效算法，这类图像滤镜特效算法广泛应用于各大PC/移动端修图软件，如美图秀秀、天天P图、抖音快手等等。在学习了本专栏之后，你将可以轻松从事滤镜特效算法开发工作，甚至可以自己开发滤镜特效类软件、app等。 ...
数据结构与算法上机试验——栈实现十进制转换二进制（C语言）
11-23
适用于计算机类专业学生，试验报告
图的常用算法思路及实现（c语言）
astudybear的博客
07-26 1485
③以防图出现非连通图，所以需要写一个BFSTraverse方法循环的查看visited数组是否还有未访问的结点，有的话将该节点继续调用BFS，直至全部结点都被访问。②然后for循环找他的邻接结点，并且将他的结点都调用DFS算法，这样递归调用就会使其一直访问下去，直到它最深的结点然后回溯回去。②然后判断队列是否空，不为空就取出第一个数据，然后将其相邻结点依次访问并放入队列中，且标记已访问。①访问第一个结点v，然后将visited数组标记为已访问并且将其放入队列中。弗洛伊德算法（Floyed）.........
数据结构之图（C语言）
sskdspdl的博客
10-22 2008
用C语言实现图的创建与遍历
【C语言】实现图的操作
最新发布
2301_79340423的博客
05-17 883
邻接矩阵是由顶点之间的相邻关系建立的矩阵在弧的弧头和弧尾的对应数组中插入对应弧的权值元素，后面实现的表为有向表，无向表的实现时将矩阵设计为对称矩阵。后文实现的图（本文用-1代表两点之间不存在关系）邻接表（）是用顺序结构和链表结构结合的结构实现对元素弧之间关系的存储，相较于邻接矩阵而言在存储稀疏图是更有利于节约存储空间，不会造成大量空间的浪费。上图为后面要实现的图结构。
图像处理常用算法(C/C++)
热门推荐
iloveyankitty的博客
01-22 1万+
查资料时看到的一篇博文，转下来先，原文：http://gaojinpeng1129.blog.163.com/blog/static/141659068201321194552695/ [cpp] view plain copy /*函数名称：MakegGray()                                        *
C语言数据结构：图！
qq_42319810的博客
07-10 1524
目录一、图的基本概念 1、基本概念 2、无向图、有向图 3、简单图、多重图 4、顶点的度、入度、出度 5、顶点-顶点的关系描述 6、连通图、强连通图 7、研究图的局部--子图 8、连通分量 9、生成树 10、生成森林 11、边的权、带权图/网 12、几种形态特殊的图 13、小结二、图的存储1、邻接矩阵（空间复杂度 = O（n*n））2、邻接表3、十字矩阵 和 邻接多重表 1、十字链表法​编辑 2、十字链表法性能分析 3、邻接多重表法 4、小结三、图的基本操作 1、Adjacent(G,x,y)：判断图G是
《数据结构与算法分析——C语言描述》随书练习.zip
12-27
数据结构是计算机存储、组织数据的方式，它涉及到数据的逻辑结构、物理结构以及对数据的基本操作。...通过对数据结构的理解和运用，以及对算法的学习和研究，可以帮助我们更有效地解决实际问题，提升编程能力。
数据结构——基于C语言实现杨辉三角
08-11
在实现过程中，会涉及到指针的使用，因为C语言中的数据结构操作往往依赖于指针来直接操作内存。指针可以用来动态地追踪队列的头和尾，以及存储数据。 总的来说，这个项目提供了学习和实践C语言、数据结构（特别是...
c语言实现线性表的算法-数据结构算法代码实现——线性表的定义（一） 定义线性表节点的结构.pdf
04-18
线性表是一种最常用的数据结构，由类型相同的n个（n≥0）数据元素组成的有序序列。线性表的特点是数据元素之间存在“一一对应”（序偶关系）的关系。 线性表的定义可以用二元组的形式表示为：List = (D,R)，其中D是...
经典数据结构算法c语言实现代码（大全）
12-11
N皇后问题回溯算法.txt ping.txt re.txt source.txt winsock2.txt ww.txt 万年历.txt 万年历的算法 .txt 乘方函数桃子猴.txt 乘法矩阵.txt 二分查找1.txt 二分查找2.txt 二叉排序树.txt 二叉树.txt ...
C语言数据结构与算法-图的实现
锅锅的博客
08-17 1160
一、介绍
王道数据结构【图】部分代码实现（C语言）
年少的勇气已经用完，剩下的就是三思而后行
07-27 2522
王道数据结构【图】部分代码实现（C语言）
数据结构C语言实现——图及最短路径实现
qq_42642142的博客
11-13 1280
本文记录了自己学习数据结构与算法课程的图结构实现及最短路径算法实现 map.h #ifndef _MAP_H_ #define _MAP_H_ #include<stdio.h> #include<stdlib.h> #include<stdbool.h> #define MAX_VERTEX_NUM 100 #define MAX_DIS INT_MAX typedef char VertexType; typedef int EdgeType; //循环队列//
C语言实现数据结构代码（四）-图-图的存储结构
Don-Talk的博客
12-06 1229
一、邻接矩阵 //邻接矩阵结构体定义 typedef struct { int no; //顶点编号 char info; //顶点其他信息，题目中无要求可不写 }VertexType; //顶点类型 typedef struct { int edge[maxSize][maxSize]; //邻接矩阵定义，如果是有权图，int改为float int n,e; //分别为顶点数和边数 VertexType vex[maxSize]; //存放结点信息 }MGraph
数据结构之图的两种遍历实现（C语言版）
m0_63932570的博客
05-04 2876
上一期文章分享完了图的两种遍历方式，也是两种很重要的算法——DFS和BFS。这两种算法的应用和重要性我就不多说了，内行的人懂的都懂。今天这文章重要就是来上机实现这两种算法，又由于这两种算法都可以由邻接矩阵和邻接表来表示，博主分享的代码都是上机测试过的，在vs2019（其他编译器我不知道行不行）上都是可以运行的。 1.深度优先搜索（DFS）: ...
C语言《数据结构》——图的概念和创建，遍历
qq_59931372的博客
04-21 4601
c语言数据结构图的创建和遍历，带你分分钟学会c语言中的重要的数据结构。
图C语言实现
beyondzty的博客
04-10 382
实现图的创建 等会儿补充DFS和BFS #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> typedef struct GNode* PtrToGNode; typedef struct ENode* PtrToENode; typedef int Vertex; typedef int WeightType; typedef char DataType; struct GNode {
数据结构C语言实现-6—图
toutuo
12-01 6273
Table of Contents 邻接矩阵创建 邻接表创建 邻接矩阵深度和广度遍历 邻接表深度和广度遍历 最小生成树—Prim 最小生成树—Kruskal 最短路径—Dijkstra 最短路径—Floyd 拓扑排序 理论部分见：数据结构理论基础-6—图 邻接矩阵创建 #include "stdio.h" #include "stdlib.h" #inclu...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

亻乍屯页女子白勺

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

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

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

打赏作者

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

抵扣说明：

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

余额充值