最小生成树-Prim算法和Kruskal算法

原文链接：https://blog.csdn.net/lsgo_myp/article/details/91435589

Prim算法

加点法

1.算法简单描述

1).输入：一个加权连通图，其中顶点集合为V，边集合为E；

2).初始化：V_new = {x}，其中x为集合V中的任一节点（起始点），E_new = {},为空；

3).重复下列操作，直到V_new = V：

a.在集合E中选取权值最小的边<u, v>，其中u为集合V_new中的元素，而v不在V_new集合当中，并且v∈V（如果存在有多条满足前述条件即具有相同权值的边，则可任意选取其中之一）；

b.将v加入集合V_new中，将<u, v>边加入集合E_new中；

4).输出：使用集合V_new和E_new来描述所得到的最小生成树。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
  
namespace ConsoleApp1
{
    class Program
    {
        //结点初始状态
        static int N = -1;
        //结点已加入状态
        static int Y = 1;
        static void Main(string[] args)
        {           
            //起始点  顶点以0开始 A顶点为0，B为1
            int start = 3;
            //无向图邻接矩阵
            int[,] map = new int[7, 7] {
                {0,7,N,5,N,N,N }, //A顶点的边
                {7,0,8,9,7,N,N }, //B顶点的边
                {N,8,0,N,5,N,N }, //C顶点的边
                {5,9,N,0,N,6,N }, //D顶点的边
                {N,7,5,N,0,8,9 }, //E 顶点的边
                {N,N,N,6,8,0,11 }, //F 顶点的边
                {N,N,N,N,9,11,0 },  //G顶点的边
            };

    //已选的点集合
    int[] vNew = new int[map.GetLength(0)];
    //置为初始状态 ,此时未加入任何结点
    for (int i = 0; i < vNew.Length; i++)
    {
        //N代表为加入结点
        vNew[i] = N;
    }
    //加入初始结点
    vNew[start] = Y;
 
    int len = GetMST(vNew, map);
 
    Console.WriteLine("最小生成树权值为："+len);
    Console.ReadKey();
}
 
/// <summary>
///   普里姆算法
/// </summary>
/// <param name="vNew">已加入的结点，初始值需设定</param>
/// <param name="map">无向图的邻接矩阵</param>
/// <returns></returns>
private static int GetMST(int[] vNew,int[,]map)
{
    //找出vNew点中与未选择的边组成的最小值
    int length = 0;
    while(vNew.Count(temp=>temp==Y)<map.GetLength(0))
    {
        int minLength = int.MaxValue;
        int minNewNode = N;
        int minStartNode = N;
        for (int i = 0; i < vNew.Length; i++)
        {
            if (vNew[i] == Y)
            {
                for (int j = 0; j < map.GetLength(1); j++)
                {
                    //未选择的结点已vNew中的结点组成的边
                    if (vNew[j] == N)
                    {
                        if (map[i, j] != N)
                        {
                            
 
                            if (map[i, j] < minLength)
                            {
                               // Console.WriteLine("边{0}{1}", i, j);
                                minLength = map[i, j];
 
                                minNewNode = j;
                                minStartNode = i;
                            }
 
                        }
 
                    }
                }
            }
 
        }
        if (minNewNode==N)
        {

            //此处图的邻接矩阵数据不正确
                    throw new Exception("图的邻接矩阵数据不正确");
                }
                else
                {
                    vNew[minNewNode] = Y;
                    Console.WriteLine("顶点{0}加入", ConvertToChar( minNewNode));
                    Console.WriteLine("边{0}--{1}加入", ConvertToChar(minStartNode), ConvertToChar(minNewNode));
                    length += minLength;
                }
            }
            return length;
        }
  
        /// <summary>
        /// 转换成字符，方便查看
        /// </summary>
        /// <param name="charValue"></param>
        /// <returns></returns>
        private static char ConvertToChar(int charValue)
        {
  
            int k = charValue + 65;
            return (char)k;
        }
    }
}