拓扑排序(极其详细)

最新推荐文章于 2024-07-09 18:04:44 发布
最新推荐文章于 2024-07-09 18:04:44 发布
阅读量678 收藏 1
点赞数 1
文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39679797/article/details/121307006
版权

0x00思路

1.前置知识:临接矩阵+图的创建+链表相关知识实现栈

2.算入度函数

3.用头插实现栈

4.再用以个void的功能函数

0x01各个函数实现

对图的一些处理

图结构体声明

typedef struct Graph {
    char* vexs;
    int** arcs;
    int vexNum;
    int arcNum;
}Graph;

图的初始化

Graph* initGraph(int vexNum) {
    Graph* G = (Graph*)malloc(sizeof(Graph));
    G -> vexs = (char*)malloc(sizeof(char) * vexNum);
    G -> arcs = (int**)malloc(sizeof(int*) * vexNum);
    for (int i = 0 ; i < vexNum; i++) {
        G -> arcs[i] = (int*)malloc(sizeof(int) * vexNum);
    }
    G -> vexNum = vexNum;
    G -> arcNum = 0;
    return G;
}

图的创建

void createGraph(Graph* G, char* vexs, int* arcs) {
    for (int i = 0 ; i < G -> vexNum; i++) {
        G -> vexs[i] = vexs[i];
        for (int j = 0; j < G -> vexNum; j++) {
            G -> arcs[i][j] = *(arcs + i * G -> vexNum + j);
            if (G -> arcs[i][j] != 0)
                G -> arcNum ++;
        }
    }
    G -> arcNum /= 2;
}

(为了检查是否创建成功,拓扑本身不需要)图的dfs遍历

void DFS(Graph* G, int* visited, int index) {
    printf("%c\t", G -> vexs[index]);
    visited[index] = 1;
    for (int i = 0; i < G ->vexNum; i++) {
        if (G -> arcs[index][i] == 1 && !visited[i]) {
            DFS(G, visited, i);
        }
    }
}

栈的实现

节点结构体声明

typedef struct Node {
    int data;
    struct Node* next;
}Node;

栈初始化

Node* initStack() {
    Node* stack = (Node*)malloc(sizeof(Node));
    stack -> data = 0;
    stack -> next = NULL;
    return stack;
}

查空函数

int isEmpty(Node* stack) {
    if (stack -> next == NULL) {
        return 1;
    }
    else {
        return 0;
    }
}

入栈出栈函数

void push(Node* stack, int data) {
    Node* node = (Node*)malloc(sizeof(Node));
    node -> data = data;
    node -> next = stack -> next;
    stack -> next = node;
    stack -> data ++;
}
​
int pop(Node* stack) {
    if (!isEmpty(stack)) {
        Node* node = stack -> next;
        stack -> next = node -> next;
        return node -> data;
    }
    else {
        return -1;
    }
}

功能函数的实现

入度计算

int* findInDegrees(Graph* G) {
    int* inDegrees = (int*)malloc(sizeof(int) * G -> vexNum);
    for (int i = 0; i < G -> vexNum; i++) {
        inDegrees[i] = 0;
    }
    for (int i = 0 ; i < G -> vexNum; i++) {
        for (int j = 0; j < G -> vexNum; j++) {
            if (G -> arcs[i][j])
                inDegrees[j] = inDegrees[j] + 1;
        }
    }
    return inDegrees;
}

拓扑功能函数

void topologicalSort(Graph* G) {
    int index = 0;
    int* top = (int*)malloc(sizeof(int) * G -> vexNum);
    int* inDegrees = findInDegrees(G);
    Node* stack = initStack();
    for (int i = 0 ; i < G -> vexNum; i++) {
        if (inDegrees[i] == 0) {
            push(stack, i);
        }
    }
    while (!isEmpty(stack)) {
        int vex = pop(stack);
        top[index++] = vex;
        for (int i = 0 ; i < G -> vexNum; i++) {
            if (G -> arcs[vex][i]) {
                inDegrees[i] = inDegrees[i] - 1;
                if (inDegrees[i] == 0) 
                    push(stack, i);
            }
        }
    }
    for (int i = 0; i < index; i++) {
        printf("%c ", G -> vexs[top[i]]);
    }
    printf("\n");
}

main

int main() {
    Graph* G = initGraph(6);
    int* visited = (int*)malloc(sizeof(int) * G -> vexNum);
    for (int i = 0; i < G -> vexNum; i++)
        visited[i] = 0;
    int arcs[6][6] = {
        0,1,1,1,0,0,
        0,0,0,0,0,0,
        0,1,0,0,1,0,
        0,0,0,0,1,0,
        0,0,0,0,0,0,
        0,0,0,1,1,0
    };
    createGraph(G, "123456", (int*)arcs);
    DFS(G, visited, 0);
    printf("\n");
    topologicalSort(G);
    return 0;
}

0x02几个有意思的问题

1.为什么要用栈

ans:1.减少时间复杂度,把入度为0的直接先压栈 2.在while遍历时,不断if入度为0压栈,不为0入度-1,执行一次出栈一个 3.ps相同入度,先入后出

2.为什么要定义top数组

ans:因为你push,pop进去的是下标,这个下标是数字,但是你的图的data不一定是数字,所以需要一个"哈希"数组进行对应,index也是在这里用来给哈系数组下标自增的, 也就是"人形自走数组产生器"哈哈哈哈哈

3.idnex干啥用

ans:如上

4.初始化的艺术

ans:我更倾向于把需要用的东西在main函数准备好,然后哪个函数需要啥,传参传啥,

luciffer更喜欢在需要用到这个东西的函数里面初始化并获取,如创建队列,我认为本质问题还是自己逻辑

不够清楚,我的"客制化盲写代码也会附上"

5.关于任意给个例子测试

ans:图的入度很讲究的,我认为有一定的规律可循(有向拓扑图),不能随便给个入度去跑

0x03Code

规范版

#include <stdio.h>
#include <stdlib.h>
​
typedef struct Graph {
    char* vexs;
    int** arcs;
    int vexNum;
    int arcNum;
}Graph;
​
typedef struct Node {
    int data;
    struct Node* next;
}Node;
​
Node* initStack() {
    Node* stack = (Node*)malloc(sizeof(Node));
    stack -> data = 0;
    stack -> next = NULL;
    return stack;
}
​
int isEmpty(Node* stack) {
    if (stack -> next == NULL) {
        return 1;
    }
    else {
        return 0;
    }
}
​
void push(Node* stack, int data) {
    Node* node = (Node*)malloc(sizeof(Node));
    node -> data = data;
    node -> next = stack -> next;
    stack -> next = node;
    stack -> data ++;
}
​
int pop(Node* stack) {
    if (!isEmpty(stack)) {
        Node* node = stack -> next;
        stack -> next = node -> next;
        return node -> data;
    }
    else {
        return -1;
    }
}
​
int* findInDegrees(Graph* G) {
    int* inDegrees = (int*)malloc(sizeof(int) * G -> vexNum);
    for (int i = 0; i < G -> vexNum; i++) {
        inDegrees[i] = 0;
    }
    for (int i = 0 ; i < G -> vexNum; i++) {
        for (int j = 0; j < G -> vexNum; j++) {
            if (G -> arcs[i][j])
                inDegrees[j] = inDegrees[j] + 1;
        }
    }
    return inDegrees;
}
​
void topologicalSort(Graph* G) {
    int index = 0;
    int* top = (int*)malloc(sizeof(int) * G -> vexNum);
    int* inDegrees = findInDegrees(G);
    Node* stack = initStack();
    for (int i = 0 ; i < G -> vexNum; i++) {
        if (inDegrees[i] == 0) {
            push(stack, i);
        }
    }
    while (!isEmpty(stack)) {
        int vex = pop(stack);
        top[index++] = vex;
        for (int i = 0 ; i < G -> vexNum; i++) {
            if (G -> arcs[vex][i]) {
                inDegrees[i] = inDegrees[i] - 1;
                if (inDegrees[i] == 0) 
                    push(stack, i);
            }
        }
    }
    for (int i = 0; i < index; i++) {
        printf("%c ", G -> vexs[top[i]]);
    }
    printf("\n");
}
​
Graph* initGraph(int vexNum) {
    Graph* G = (Graph*)malloc(sizeof(Graph));
    G -> vexs = (char*)malloc(sizeof(char) * vexNum);
    G -> arcs = (int**)malloc(sizeof(int*) * vexNum);
    for (int i = 0 ; i < vexNum; i++) {
        G -> arcs[i] = (int*)malloc(sizeof(int) * vexNum);
    }
    G -> vexNum = vexNum;
    G -> arcNum = 0;
    return G;
}
​
void createGraph(Graph* G, char* vexs, int* arcs) {
    for (int i = 0 ; i < G -> vexNum; i++) {
        G -> vexs[i] = vexs[i];
        for (int j = 0; j < G -> vexNum; j++) {
            G -> arcs[i][j] = *(arcs + i * G -> vexNum + j);
            if (G -> arcs[i][j] != 0)
                G -> arcNum ++;
        }
    }
    G -> arcNum /= 2;
}
​
void DFS(Graph* G, int* visited, int index) {
    printf("%c\t", G -> vexs[index]);
    visited[index] = 1;
    for (int i = 0; i < G ->vexNum; i++) {
        if (G -> arcs[index][i] == 1 && !visited[i]) {
            DFS(G, visited, i);
        }
    }
}
​
int main() {
    Graph* G = initGraph(6);
    int* visited = (int*)malloc(sizeof(int) * G -> vexNum);
    for (int i = 0; i < G -> vexNum; i++)
        visited[i] = 0;
    int arcs[6][6] = {
        0,1,1,1,0,0,
        0,0,0,0,0,0,
        0,1,0,0,1,0,
        0,0,0,0,1,0,
        0,0,0,0,0,0,
        0,0,0,1,1,0
    };
    createGraph(G, "123456", (int*)arcs);
    DFS(G, visited, 0);
    printf("\n");
    topologicalSort(G);
    return 0;
}

我的"客制化"版本(阉割

#include <stdio.h>
#include <stdlib.h>
typedef struct Node{
    int data;
    struct Node *next;
}Node;
int isempty(Node *D){
    if(D -> next == NULL) return 1;
    if(D -> next != NULL) return 0;
}
Node* init(){
    Node *D = (Node*)malloc(sizeof(Node));
    D -> next = NULL;
    D -> data = 0;
    return D;
}
void push(Node *D,int data){
    Node *node = (Node*)malloc(sizeof(Node));
    node -> next = D -> next;
    D -> next = node;
    node -> data = data;
    D -> data = D -> data + 1;
}
int pop(Node *D){
    int i = D -> next -> data;
    D -> next = D -> next -> next;
    return i;   
}
int* findIndegree(int* ljjz){
    int *indegree = (int*)malloc(sizeof(int)*4);
    for(int i = 0;i < 4;i++){
        for(int j = 0;j < 4;j++){
            if(*(ljjz+i*4+j)!=0){
                (*(ljjz+i*4+j))--;
                (*(indegree+j))++;
            }
        }
    }
    return indegree;
}
void topology(int *indegree,Node *stack,char *zifu){
    int index = 0;
    int *ans = (int*)malloc(sizeof(int)*4);
    for(int i =0;i < 4;i++){
        if(indegree[i]==0) push(stack,i);
        else{
            indegree[i]--;
        }
    }
    while(!isempty(stack)){
        int i = pop(stack);
        ans[index++] = i ;
        for(int i = 0;i < 4; i++){
            if(indegree[i]!=0){
                indegree[i]--;
                if(indegree[i]==0){
                    push(stack,i);
                }
            }
        }
    }
    for(int i = 0; i < index; i++){
        printf("%c ",zifu[ans[i]] );
    }
    printf("\n");
}
int main(){
    char *zifu = "ABCD";
    int ljjz[4][4] = {
        0,1,1,0,
        0,0,0,1,
        0,1,0,1,
        0,0,0,0
    };
    Node* stack = init();
    int *indegree = findIndegree(ljjz);
    topology(indegree,stack,zifu);
}
LiujiaHuan13
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
拓扑排序（简述）
zizi0092011的博客
01-05 7532
拓扑排序是一个比较常用的图论算法，经常用于完成有依赖关系的任务的排序。 举个栗 例子：有人想要制作一件工具，但是这个工具不是一次就可以完成的，分很多个步骤，而且这些步骤是有顺序的，也就是说，假设B的顺序在A的后面，那么你就必须要先完成A再完成B，但是也有些步骤不分顺序，意思是你先做哪一个都是可以的。 面对这样的问题，我们可以把步骤建立成一张有向无环图，A指向B意思是A要在B前面完成，那么下面，我们...
拓扑排序详解
Mohogany_P的博客
07-21 899
        拓扑排序这种新手算法，在一年前我就已经系统地学过，但由于各种各样的原因，我不是很理解。在最近的比赛中，又遇到了一道拓扑排序题，尽管我运用堆勉强解决，但还是很不甘心，所以今天来复习一下拓扑排序。         先来说说拓扑排序是什么。虽然名字叫排序，但拓扑排序却不是我们平常说的排序。对于一个有向无环图G=(V,E)来说，其拓扑排序是其所有结点的一种线性次序，该次序满足如下条件：如...
图论基础——拓扑排序
weixin_44269491的博客
03-05 478
拓扑排序 拓扑排序所解决的问题是在一些有向图中，需要完成一些前置条件，也即走完这个点的所有前置的点才能前往该点，要得到一个顺序； 这个问题需要基于入度来思考，需要一个入度数组来记录指向每个点的入度个数，当这个点的入度为0时就是这个点所有前置条件都完成了可以前往该点了； 因此需要一个数据结构来保存所有入度为0的点，可以是队列，栈或者是优先队列，当然数组也可以； 代码实现： 由于需要以某点为起点遍历所有边所以用链式前向星来存边； 采用栈的形式来保存所有入度为0的点； 最后结果： 拓扑排序检测有向图是否存在
拓扑排序详解（包含算法原理图解、算法实现过程详解、算法例题变式全面讲解等）
aliyonghang的博客
05-06 9671
非常详细的讲解。点开有惊喜！
使用 堆栈 和 队列 分别实现 基于深度优先的拓扑排序
weixin_67051070的博客
08-04 786
拓扑排序
【数据结构】拓扑排序的实现
Hamdh的博客
09-11 268
在拓扑排序中，图中的顶点表示任务或事件，有向边表示任务间的依赖关系。
拓扑排序中的栈存储结构
云计算?
01-17 405
近期看数据结构，看到拓扑排序中的栈存储数据结构，上面的栈使用数组进行存储，而非Stack定义，使用的非常妙，分享一下。 拓扑排序的主要思想：（1）选择一个入度为0的顶点并输出；（2）从网中删除此顶点及其所有边；（3）重复执行（1）（2）直到不存在入度为0的顶点；比如下面所示的图（采用邻接表表示）： 设置保存每个顶点的入度值的数组d，则d如下所示： 方式一：直接使用d数组作为栈，栈的使...
top.zip_拓扑排序
09-23
在本压缩包文件"top.zip_拓扑排序"中，包含的两个源代码文件"top.cpp"和"逆拓扑排序.cpp"分别展示了拓扑排序的基本实现和逆向拓扑排序的算法。 首先，我们来看"top.cpp"。这个文件很可能是实现了一种基本的拓扑排序...
数据结构拓扑排序
06-24
数据结构拓扑排序
tuopupaixu.rar_拓扑排序
09-21
"新建 文本文档.txt"和"www.pudn.com.txt"可能是文档或链接，可能包含更详细的代码解释或拓扑排序的应用示例。如果你在理解和使用这些资源时遇到困难，可以通过描述中提到的方式联系提供者寻求帮助。 总结来说，...
细讲拓扑排序
12-04
该PPT详细的讲了拓扑序，适合初学者看，可有点简单，所以你只用1积分就可以下载了。
拓扑排序拓扑排序拓扑排序
11-03
下面详细介绍拓扑排序的步骤和C++实现的关键点： 1. **建立邻接表**：首先，我们需要将图的数据结构表示出来，通常选择邻接表，因为它在处理稀疏图时更节省空间。邻接表是一个二维数组或链表的集合，其中每个顶点都...
栈和队列的主要区别
m0_49591105的博客
12-30 3911
一、规则不同 1. 队列：先进先出（First In First Out）FIFO 2. 栈：先进后出（First In Last Out ）FILO 二、对插入和删除操作的限定不同 1. 队列：只能在表的一端进行插入，并在表的另一端进行删除； 2. 栈：只能在表的一端插入和删除。 三、遍历数据速度不同 1. 队列：基于地址指针进行遍历，而且可以从头部或者尾部进行遍历，但不能同时遍历，无需开辟空间，因为在遍历的过程中不影响数据结构，所以遍历速度要快； 2. 栈：只能从顶部取数据，也就是说最先
拓扑排序
weixin_44266050的博客
02-21 1911
文章目录应用定义注意应用案例题1（栈）问题 A: 算法7-12：有向无环图的拓扑排序题2（优先队列）问题 B: 确定比赛名次 应用   可用拓扑排序判断是否为有向无环图（只有排序成功才可以称之为有向无环图） 定义   拓扑排序是将有向无环图G的所有顶点排成一个线性序列，使得对图G中的任意两个顶点u、V, 如果存在边u->v, 那么在序列中u一定在v前面。这个序列又被称为拓扑序列。 步骤 （1...
拓扑排序（dfs用栈，bfs用队列）
weixin_42738495的博客
05-17 1912
现在你总共有 n 门课需要选，记为 0 到 n-1。 在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1] 给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。 可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。 示例 1: 输入: 2, [[1,0]] 输出: [0,1] 解释: 总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。
拓扑排序的原理及其实现
热门推荐
不忘初心，好好沉淀
07-04 21万+
本文将从以下几个方面介绍拓扑排序： 拓扑排序的定义和前置条件和离散数学中偏序/全序概念的联系典型实现算法 Kahn算法基于DFS的算法 解的唯一性问题实际例子 取材自以下材料： http://en.wikipedia.org/wiki/Topological_sorting http://en.wikipedia.org/wiki/Hamiltonian_pat
拓扑排序(topological sorting)介绍及Python实现
chenxy_bwave的专栏
06-01 2万+
拓扑排序(topological sorting)介绍及Python实现，介绍了拓扑排序基本算法原理，并给出基于深度优先搜索和基于广度优先搜索的Python实现。
数据结构--树和二叉树的一些知识点总结
最新发布
weixin_68489989的博客
07-09 426
数据结构--树和二叉树的一些知识点总结
拓扑排序 leetcode
09-14
拓扑排序（Topological Sort）是指对有向无环图（DAG）进行排序的算法。在拓扑排序中，对于任意的有向边 (u, v)，结点 u 必须在结点 v 之前出现。拓扑排序可以用于解决依赖关系的排序问题，比如编译器的依赖关系、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

LiujiaHuan13

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

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

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

打赏作者

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

抵扣说明：

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

余额充值