【c语言】Prim算法与Kruskal算法的比较与实现，寻找最小支撑树（生成树）

最新推荐文章于 2024-05-31 18:03:22 发布

汐新酱

最新推荐文章于 2024-05-31 18:03:22 发布

阅读量789

点赞数 11

分类专栏：离散数学文章标签：算法 c语言数据结构排序算法

本文链接：https://blog.csdn.net/xixin2233/article/details/137939296

版权

离散数学专栏收录该内容

8 篇文章 0 订阅

订阅专栏

实验目的

Learn and understand the Prim algorithm, Kruskal algorithm through programming, and implement the prim algorithm by using the cocycle method. Compare and distinguish the application scope of different algorithms in learning

实验内容

Prim algorithm, Kruskal algorithm are implemented in the computer by programming in C-language to find the Minimum spanning tree. The prim algorithm tries to use the cocycle method.

使用环境

Win 11 & visual studio code 2022

算法介绍

调试过程

调试代码

The program takes the file as the input, and the file content is

Code:

#include <stdio.h>
#include <stdlib.h>
#define V 4 // V是图的顶点数
struct graph
{
    char vert1;
    char vert2;
    int weight;
};
typedef struct graph graph;
graph edge[10];
int n = 0;
int MOG[10][10];
graph minitree[V - 1]; // 最小树的边是顶点数减一

void matrify(int m) // 转换为矩阵
{
    int i, x, y;
    for (i = 0; i < m; i++)
    {
        x = edge[i].vert1 - 65;
        y = edge[i].vert2 - 65;
        MOG[x][y] = MOG[y][x] = edge[i].weight;
    }
}
void showM()
{
    int i, j;
    for (i = 0; i < V; i++) // 打印权重矩阵
    {
        for (j = 0; j < V; j++)
        {
            printf("%d ", MOG[i][j]);
        }
        printf("\n");
    }
}
void PRIM()
{
    int i, j, minw, temp;
    int a, b, s = 0, M = V - 2;
    while (M > 0)
    {
        minw = MOG[0][1];
        for (i = 0; i < V - 1; i++) // 找最小权重
        {
            for (j = i + 1; j < V; j++) // 遍历一半的矩阵即可
            {
                temp = MOG[i][j];
                if (temp < minw && temp != 0)
                {
                    minw = temp;
                    a = i;
                    b = j;
                }
            }
        }
        minitree[s].vert1 = (a + 65);
        minitree[s].vert2 = (b + 65);
        minitree[s].weight = minw;
        s++;
        for (i = 0; i < V; i++) // 合并行
        {
            if (MOG[a][i] != 0 && MOG[b][i] != 0)
                MOG[a][i] = (MOG[a][i] < MOG[b][i]) ? MOG[a][i] : MOG[b][i];
            else
                MOG[a][i] = MOG[a][i] + MOG[b][i];
        }
        for (j = 0; j < V; j++) // 合并列
        {
            if (MOG[j][a] != 0 && MOG[j][b] != 0)
                MOG[j][a] = (MOG[j][a] < MOG[j][b]) ? MOG[j][a] : MOG[j][b];
            else
                MOG[j][a] = MOG[j][a] + MOG[j][b];
        }
        for (i = 0; i < V; i++)
        {
            MOG[b][i] = MOG[i][b] = 0;
            MOG[i][i] = 0; // 对角线为0
        }
        M--;
        printf("Matrix of weights:\n");
        showM(); // 展示每一步
    }
    matrify(n);
    for (i = 0; i < (V - 2); i++)
    {
        a = minitree[i].vert1 - 65;
        b = minitree[i].vert2 - 65;
        MOG[a][b] = MOG[b][a] = 0;
    }
    minw = MOG[0][1];
    for (i = 0; i < V - 1; i++)
    {
        for (j = i + 1; j < V; j++)
        {
            temp = MOG[i][j];
            if (temp < minw && temp != 0)
            {
                minw = temp;
                a = i;
                b = j;
            }
        }
    }
    minitree[s].vert1 = (a + 65);
    minitree[s].vert2 = (b + 65);
    minitree[s].weight = minw;
}

int main()
{
    int i, j;
    FILE *fp;
    fp = fopen("D:/work code/C Storageroom/discrete/graph01.txt", "r"); // 只读的方式打开文件
    if (fp == NULL)                                                     // 判断文件是否正常打开
    {
        printf("can not open the file\n");
        exit(0);
    }
    while (!feof(fp)) // 从文件中读入数据
    {
        edge[n].vert1 = fgetc(fp);
        edge[n].vert2 = fgetc(fp);
        fscanf(fp, "%d", &edge[n].weight);
        n++;
    }
    fclose(fp);             // 关闭文件
    for (i = 0; i < n; i++) // 打印数据
        printf("%c %c %d\n", edge[i].vert1, edge[i].vert2, edge[i].weight);
    matrify(n);
    printf("the matrix of weights\n");
    showM();
    PRIM();
    printf("output:\n");
    for (i = 0; i < (V - 1); i++) // 打印数据
        printf("%c %c %d\n", minitree[i].vert1, minitree[i].vert2, minitree[i].weight);
    return 0;
}

运行结果

总结

The spanning tree of an undirected graph is to select some edges from the edge set of the graph, so that these edges form a connected acyclic graph, that is, a tree. If a weight is added to each edge, the spanning tree with the smallest sum of weights in all spanning trees is called the minimum spanning tree. Prim algorithm and Kruskal algorithm are algorithms that use MST properties to construct the minimum spanning tree. The experimental graph is stored in the form of adjacency matrix. Sometimes the results of Prim algorithm are not unique.