dijkstra C

想要成为社畜的大学生

已于 2024-02-28 12:54:43 修改

阅读量105

点赞数 3

文章标签：深度优先算法图论

于 2024-02-15 01:41:38 首次发布

本文链接：https://blog.csdn.net/zxxcccc11/article/details/136117670

版权

文章详细介绍了如何在C语言中使用结构体和函数实现图的初始化、边的创建、深度优先搜索(DFS)以及Dijkstra算法来求解最短路径。

摘要由CSDN通过智能技术生成

#include <stdio.h>
#include <stdlib.h>

#define MAX 32767

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->arcs[i][j] != MAX)
                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] > 0 && G->arcs[index][i] != MAX && !visited[i]) {
            DFS(G, visited, i);
        }
    }
}
int getMin(int*D,int*S,Graph*G) {
    int min = MAX;
    int get = 0;
    for (int i = 0; i < G->vexNum; i++)
    {
        if (!S[i]&&D[i]<min)
        {
            min = D[i];
            get = i;
        }
    }
    return get;
}
void dijkstra(Graph*G,int index) {
    int* S = (int*)malloc(sizeof(int) * G->vexNum);
    int* P = (int*)malloc(sizeof(int) * G->vexNum);
    int* D = (int*)malloc(sizeof(int) * G->vexNum);
    for (int i = 0; i < G->vexNum; i++)
    {
        if (i==index)
        {
            S[i] = 1;
        }
        else
        {
            S[i] = 0;
        }
    }
    for (int i = 0; i < G->vexNum; i++)
    {
        if (G->arcs[index][i]!=MAX&&G->arcs[index][i]>0)
        {
            P[i] = index;
        }
        else
        {
            P[i] = -1;
        }
    }
    for (int i = 0; i < G->vexNum; i++)
    {
        if (G->arcs[index][i]!=MAX&&G->arcs[index][i]>0)
        {
            D[i] = G->arcs[index][i];
        }
        else
        {
            D[i] = MAX;
        }
    }
    for (int i = 0; i < G->vexNum; i++)
    {
        int get = getMin(D,S,G);
        S[get] = 1;
        for (int j = 0; j < G->vexNum; j++)
        {
            if (!S[j]&&D[get]+G->arcs[get][j]<D[j])
            {
                D[j] = D[get] + G->arcs[get][j];
                P[j] = get;
            }
        }
    }
    for (int i = 0; i < G->vexNum; i++) {
        printf("%d %d %d\n", S[i], P[i], D[i]);
    }
}


int main() {
    Graph* G = initGraph(7);
    int* visited = (int*)malloc(sizeof(int) * G->vexNum);
    for (int i = 0; i < G->vexNum; i++)
        visited[i] = 0;
    int arcs[7][7] = {
        0, 12, MAX, MAX, MAX, 16, 14,
        12, 0, 10, MAX, MAX, 7, MAX,
        MAX, 10, 0, 3, 5, 6, MAX,
        MAX, MAX, 3, 0, 4, MAX, MAX,
        MAX, MAX, 5, 4, 0, 2, 8,
        16, 7, 6, MAX, 2, 0, 9,
        14, MAX, MAX, MAX, 8, 9, 0
    };
    createGraph(G, "1234567", (int*)arcs);
    DFS(G, visited, 0);
    printf("\n");
    dijkstra(G, 0);
    return 0;
}

参考：

分类: Data Structure | tyrantlucifer