Prim算法

今天学习了prim算法。严奶奶的代码我没看懂，毕竟她都80岁了。算了，我自己按照书上的描述写了一个。

今天学习的Java知识点：调用类中的类进行变量声明可以使用  className.innerClassName objectName 这种声明方式。

解题所用数据结构：邻接矩阵。

可视化：

邻接矩阵prim.txt：（-1代表 ∞ ）

-1 6 1 5 -1 -1
6 -1 5 -1 3 -1
1 5 -1 5 6 4
5 -1 5 -1 -1 2
-1 3 6 -1 -1 6
-1 -1 4 2 6 -1

解题代码：（Java）

    void prim(){
        int i,j;
        List<Integer> V=new ArrayList<Integer>();//集合V
        List<Integer> U=new ArrayList<Integer>();//集合U
        for(i=1;i<vexnum;i++) V.add(i);            //V初始化
        U.add(0);                                //U初始化
        while(V.size()>0){
            int min=10000;
            int a=0;//源点
            int b=0;//目标点
            for(i=0;i<U.size();i++){//取出U中每一个元素
                int u=U.get(i);//每一次取出的元素
                for(j=0;j<V.size();j++){//j
                    int v=V.get(j);
                    int value=adjMatrix[u][v];//取出的元素
                    if(value!=-1 && value<min){
                        min=value;
                        a=u;
                        b=v;
                    }
                }
            }
            U.add(b);
            V.remove(V.indexOf(b));
            System.out.println(a+"->"+b);
        }
    }

输出：

0->2
2->5
5->3
2->1
1->4

今天编写的完整代码：（Java）

import java.io.*;
import java.util.*;

public class demo {
    public static void main(String args[]){
        Graph grath=new Graph("D:/JavaWorkspace/图状结构/prim.txt");
        System.out.println("邻接矩阵：");
        System.out.println(grath);
        System.out.println("邻接链表：");
        System.out.println(grath.getListStr());
        System.out.println("最小生成树：");
        grath.prim();
    }
}

class Graph{
    int [][] adjMatrix;//adjacency matrix 邻接矩阵数据结构
    int vexnum=0;        //顶点数目
    AdjList adjList=null;
    class AdjList{        //邻接表
        class VNode{    //顶点节点。头节点
            int index=0;//顶点编号
            ANode firstArc=null;//第一个弧节点
        }
        class ANode{            //弧节点
            int adjVex=0;        //所指向顶点位置
            ANode nextArc=null;    //下一条弧
        }
        VNode vnodes[]=null;
        AdjList(){
        }
        AdjList(int [][] nums,int v){//用二维数组进行构造
            vnodes=new VNode[v];
            int i,j;
            for(i=0;i<v;i++){
                vnodes[i]=new VNode();
                vnodes[i].index=i+1;//顶点数组初始化
            }
            for(i=0;i<v;i++){
                for(j=0;j<v;j++){            //对邻接矩阵进行遍历
                    if(nums[i][j]!=-1){        //有元素
                        ANode arc=new ANode();
                        arc.adjVex=j;
                        if(vnodes[i].firstArc==null) vnodes[i].firstArc=arc;
                        else{
                            ANode node=vnodes[i].firstArc;
                            while(node.nextArc!=null) node=node.nextArc;
                            node.nextArc=arc;        //勾链
                        }
                    }
                }
            }
        }
    }
    String getListStr(){//打印邻接链表
        int i;
        String str=new String();
        for(i=0;i<vexnum;i++){
            str+=Integer.toString(adjList.vnodes[i].index);
            str+="：";
            AdjList.ANode node=adjList.vnodes[i].firstArc;
            while(node!=null){
                str+=Integer.toString(node.adjVex);
                str+="->";
                node=node.nextArc;
            }
            str+="∧
";
        }
        return str;
    }
    public String toString(){
        String str=new String();
        int i,j;
        for(i=0;i<vexnum;i++){
            for(j=0;j<vexnum;j++){            //对邻接矩阵进行遍历
                str+=Integer.toString(adjMatrix[i][j]);
                str+=" ";
            }
            str+="
";
        }
        return str;
    }
    Graph(String path){//通过文件路径，输入文件来读取邻接矩阵
        String content=MyFile.readFile(path);//读取文件内容
        String lines[]=content.split("
");
        String probe[];
        vexnum=lines.length;
        adjMatrix=new int[vexnum][vexnum];//刻画邻接矩阵大小
        
        int i,j;
        for(i=0;i<lines.length;i++){
            probe=lines[i].split(" ");
            for(j=0;j<probe.length;j++){
                adjMatrix[i][j]=Integer.valueOf(probe[j]).intValue();//要对integer进行拆包
            }
        }
        adjList=new AdjList(adjMatrix,lines.length);//构造本类中的邻接链表
    }
/*        class CloseEdge{        //记录 U-V 中各顶点到 U 中权值最小的边
            int adjvex=0;    //边所依附于 U 中的顶点
            int lowcost=0;    //这条边的权值（代价最小）
        }
        CloseEdge closedge[]=new CloseEdge[vexnum];//构建数组
*/        
    void prim(){
        int i,j;
        List<Integer> V=new ArrayList<Integer>();//集合V
        List<Integer> U=new ArrayList<Integer>();//集合U
        for(i=1;i<vexnum;i++) V.add(i);            //V初始化
        U.add(0);                                //U初始化
        while(V.size()>0){
            int min=10000;
            int a=0;//源点
            int b=0;//目标点
            for(i=0;i<U.size();i++){//取出U中每一个元素
                int u=U.get(i);//每一次取出的元素
                for(j=0;j<V.size();j++){//j
                    int v=V.get(j);
                    int value=adjMatrix[u][v];//取出的元素
                    if(value!=-1 && value<min){
                        min=value;
                        a=u;
                        b=v;
                    }
                }
            }
            U.add(b);
            V.remove(V.indexOf(b));
            System.out.println(a+"->"+b);
        }
    }
    private boolean findInNum(int[] arr,int obj){
        for(int i=0;i<arr.length;i++) if(arr[i]==obj) return true;
        return false;
    }
    
    
}

class MyFile{

    /**
     * 创建文件
     * @param fileName  文件名称
     * @param filecontent   文件内容
     * @return  是否创建成功，成功则返回true
     */
    public static boolean createFile(String fileName){
        boolean bool = false;
        File file = new File(fileName);
        try {
            //如果文件不存在，则创建新的文件
            if(!file.exists()){
                file.createNewFile();
                bool = true;
                System.out.println("success create file,the file is "+fileName);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bool;
    }
    
    /**
     * 向文件中写入内容
     * @param filepath 文件路径与名称
     * @param newstr  写入的内容
     * @return
     * @throws IOException
     */
    public static boolean writeFile(String filepath,String newstr) throws IOException{
        boolean bool = false;
        String filein = newstr+"
";//新写入的行，换行
        String temp  = "";
        
        FileInputStream fis = null;
        InputStreamReader isr = null;
        BufferedReader br = null;
        FileOutputStream fos  = null;
        PrintWriter pw = null;
        try {
            File file = new File(filepath);//文件路径(包括文件名称)
            //将文件读入输入流
            fis = new FileInputStream(file);
            isr = new InputStreamReader(fis);
            br = new BufferedReader(isr);
            StringBuffer buffer = new StringBuffer();
            
            //文件原有内容
            for(int i=0;(temp =br.readLine())!=null;i++){
                buffer.append(temp);
                // 行与行之间的分隔符 相当于“
”
                buffer = buffer.append(System.getProperty("line.separator"));
            }
            buffer.append(filein);
            
            fos = new FileOutputStream(file);
            pw = new PrintWriter(fos);
            pw.write(buffer.toString().toCharArray());
            pw.flush();
            bool = true;
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }finally {
            //不要忘记关闭
            if (pw != null) {
                pw.close();
            }
            if (fos != null) {
                fos.close();
            }
            if (br != null) {
                br.close();
            }
            if (isr != null) {
                isr.close();
            }
            if (fis != null) {
                fis.close();
            }
        }
        return bool;
    }
 
    /**
     * 删除文件
     * @param fileName 文件名称
     * @return
     */
    public static boolean delFile(String fileName){
        boolean bool = false;
        File file  = new File(fileName);
        try {
            if(file.exists()){
                file.delete();
                bool = true;
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
        return bool;
    }
    public static String readFile(String fileName) {
        File file = new File(fileName);
        Reader reader = null;
        String content=new String();
        try {
            // 一次读一个字符
            reader = new InputStreamReader(new FileInputStream(file));
            int tempchar;
            while ((tempchar = reader.read()) != -1) {
                // 对于windows下，
这两个字符在一起时，表示一个换行。
                // 但如果这两个字符分开显示时，会换两次行。
                // 因此，屏蔽掉
，或者屏蔽
。否则，将会多出很多空行。
                if (((char) tempchar) != '
') {
                 //   System.out.print((char) tempchar);
                    content+=((char) tempchar);
                }
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return content;
    }
}

 程序完成输出：

邻接矩阵：
-1 6 1 5 -1 -1
6 -1 5 -1 3 -1
1 5 -1 5 6 4
5 -1 5 -1 -1 2
-1 3 6 -1 -1 6
-1 -1 4 2 6 -1

邻接链表：
1：1->2->3->∧
2：0->2->4->∧
3：0->1->3->4->5->∧
4：0->2->5->∧
5：1->2->5->∧
6：2->3->4->∧

最小生成树：
0->2
2->5
5->3
2->1
1->4