最小生成树的prim算法

最新推荐文章于 2024-03-01 11:05:40 发布

luojinping

最新推荐文章于 2024-03-01 11:05:40 发布

阅读量1.3k

点赞数

分类专栏：算法文章标签： null 算法数据结构 string 测试

算法专栏收录该内容

13 篇文章 1 订阅

订阅专栏

在无向加权图中，n个顶点的最小生成树有n-1条边，这些边使得n个顶点之间可达，且总的代价最小。

prim算法是一种贪心算法，将全部的顶点划分为2个集合，每次总在2个集合之间中找最小的一条边，局部最优最终达到全局最优，这正是贪心的思想。
具体的描述参见相关书籍：

描述

从单一顶点开始，普里姆算法按照以下步骤逐步扩大树中所含顶点的数目，直到遍及连通图的所有顶点。

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

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

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

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

2. 将v加入集合V_new中，将（u, v）加入集合E_new中；

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

prim的实现：

1 //prim最小生成树
2
3     public Edge[] getEdges(int position){    //返回从顶点position开始的最小生成树的边数组
4         Edge[] edges = new Edge[size()-1];    //最小生成树里边数为n-1,!!!!size()
5         VNodes[position].setVisited(true);    //将原来的遍历中用的标志在这分离集合
6         for(int i = 0;i <edges.length;i++)    //找n-1条边出来
7         {
8             Edge edge =getMinEdge(VNodes);        //在当前分离的2个集合之间找到最小边
9             edges[i] = edge;
10             VNodes[edge.getEnd()].setVisited(true);//将新添加的边的另一端的顶点分离出来
11         }
12         return edges;
13     }
14
15     private Edge getMinEdge(VNode[] VNodes){   //从分离的2个集合之间求出最小的边
16         return min;
17     }
18
19     private boolean hasEdge(VNode node){   //判断某个标记true的顶点跟另一个集合之间是否有边
20         return false;
21     }
22
23
24     private Edge getMinEdgeFrom(VNode node){ //如果有边（前提），求出这个顶点到对方集合的最小边
25         return min;
26     }
27
28

因为我存的是顶点，所以还要找边，比较麻烦一点，如果在图中记录了一个边得数组，就可以直接在边得数组里面去找最小边。

解决问题的思路是先很容易就可以写出上述最小生成树的逻辑实现，然后去一一实现支持它的方法。

三个支持方法的实现：

private Edge getMinEdge(VNode[] VNodes){   //从分离的2个集合之间求出最小的边
        Edge min = null;
        //for(int i = 0;i < VNodes.length;i++)
        for(int i = 0;i <size();i++)
        {
            if(VNodes[i].getVisited() && hasEdge(VNodes[i]))//从true集合向false集合找
            {
                Edge temp =getMinEdgeFrom(VNodes[i]);
                if(min == null)//第一次的初始化min
                    min = temp;
                else if(temp.getLen()< min.getLen())
                    min = temp;
            }
        }
        return min;
    }

    private boolean hasEdge(VNode node){   //判断某个标记true的顶点跟另一个集合之间是否有边
        if(node.getFirst() == null)
            return false;
        else
        {
            Edge temp = node.getFirst();
            while(temp != null)
            {
                int index = temp.getEnd();
                if(VNodes[index].getVisited() == false)
                    return true;
                else temp = temp.getNext();
            }
        }
        return false;
    }


    private Edge getMinEdgeFrom(VNode node){ //如果有边（前提），求出这个顶点到对方集合的最小边
        Edge min = null;
        Edge temp = node.getFirst();

        while(temp != null)
        {
            int index = temp.getEnd();
            if(VNodes[index].getVisited() == false)//说明此时的temp是到对方集合的一条边
            {
                if(min == null)
                    min = temp;
                else if(temp.getLen()< min.getLen())
                    min = temp;
            }
            temp = temp.getNext();
        }
        return min;
    }

然后添加一个图来测试一下：

public static void main(String[] args) {
        // TODO Auto-generated method stub
        UnDirectedGraph g = new UnDirectedGraph();

        for(int i = 1;i <7;i++)
            g.addVNode("V" +i);
        g.addEdge(0, 1, 6);
        g.addEdge(0, 2, 1);
        g.addEdge(0, 3, 5);
        g.addEdge(1, 2, 5);
        g.addEdge(1, 4, 5);
        g.addEdge(2, 3, 5);
        g.addEdge(2, 4, 6);
        g.addEdge(2, 5, 4);
        g.addEdge(3, 5, 2);
        g.addEdge(4, 5, 6);//严蔚敏数据结构中的那个图

        Edge[] edges = g.getEdges(0);
        System.out.println("输出最小生成树的边");
        for(int i = 0;i <edges.length;i++)
        {
            int start = edges[i].getStart();
            int end = edges[i].getEnd();
            System.out.println("边： " + g.VNodes[start].getVNode() +"---" +g.VNodes[end].getVNode()
                    + "   长度：" + edges[i].getLen());
        }

}