java 数据结构 图

以下内容主要来自大话数据结构之中，部分内容参考互联网中其他前辈的博客，主要是在自己理解的基础上进行记录。

　　图的定义

         图是由顶点的有穷非空集合和顶点之间边的集合组成，通过表示为G(V,E)，其中，G标示一个图，V是图G中顶点的集合，E是图G中边的集合。

         无边图：若顶点Vi到Vj之间的边没有方向，则称这条边为无项边（Edge），用序偶对(Vi,Vj)标示。

       

         有向图：若从顶点Vi到Vj的边是有方向的，则成这条边为有向边，也称为弧（Arc）。用有序对（Vi，Vj）标示，Vi称为弧尾，Vj称为弧头。如果任意两条边之间都是有向的，则称该图为有向图。

                     有向图G2中，G2=（V2,{E2}），顶点集合（A,B,C,D）,弧集合E2={<A,D>,{B,A},<C,A>,<B,C>}.

         权（Weight）：有些图的边和弧有相关的数，这个数叫做权（Weight）。这些带权的图通常称为网（Network）。

　　　　

　　图的存储结构

　　图的存储结构一般分为邻接矩阵和十字链表

　　邻接矩阵：图的邻接矩阵存储方式是用两个数组来标示图。一个一位数组存储图顶点的信息，一个二维数组（称为邻接矩阵）存储图中边或者弧的信息。

　　设图G有n个顶点，则邻接矩阵是一个n*n的方阵，定义为：

        

　　

　　十字链表： 

　　顶点表结点结构：

　　

　　firstin：表示入边表头指针，指向该顶点的入边表中第一个结点。

　　firstout：表示出边表头指针，指向该顶点的出边表中的第一个结点。

　　边表结点结构：

　　

　　tailvex：指弧起点在顶点表的下标。

　　headvex：指弧终点在顶点表中的下标。

　　headlink：指入边表指针域。

　　taillink：指边表指针域。

　　如果是网，还可以再增加一个weight域来存储权值。

　　

　　蓝线表示出度，红线表示入度

　　十字链表的优点：

　　十字链表是把邻接表和逆邻接表整合在一起，这样既容易找到以Vi为尾的弧，也容易找到以Vi为头的弧，

　　因而容易求的顶点的出度和入度。

　　

　　图的搜索：

　　深度优先遍历：也有称为深度优先搜索，简称DFS。其实，就像是一棵树的前序遍历。它从图中某个结点v出发，访问此顶点，然后从v的未被访问的邻接点出发深度优先遍历图，直至图中所有和v有      路径相通的顶点都被访问到。若图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作起始点，重复上述过程，直至图中的所有顶点都被访问到为止。

　　基本实现思想：

　　（1）访问顶点v；

　　（2）从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历；

　　（3）重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。

　　

　　广度优先遍历：也称广度优先搜索，简称BFS。BFS算法是一个分层搜索的过程，和树的层序遍历算法类同，它也需要一个队列以保持遍历过的顶点顺序，以便按出队的顺序再去访问这些顶点的邻接顶点。 

　　基本实现思想：

　　（1）顶点v入队列。

　　（2）当队列非空时则继续执行，否则算法结束。

　　（3）出队列取得队头顶点v；访问顶点v并标记顶点v已被访问。

　　（4）查找顶点v的第一个邻接顶点col。

　　（5）若v的邻接顶点col未被访问过的，则col入队列。

　　（6）继续查找顶点v的另一个新的邻接顶点col，转到步骤（5）。

        直到顶点v的所有未被访问过的邻接点处理完。转到步骤（2）。

　　广度优先遍历图是以顶点v为起始点，由近至远，依次访问和v有路径相通而且路径长度为1，2，……的顶点。为了使“先被访问顶点的邻接点”先于“后被访问顶点的邻接点”被访问，需设置队列存储访问的顶点。

　　最小生成树

　　　　我们把构造连通网的最小代价生成的树称为最小生成树，即权值最小的生成树。

 

　　实现方式：

　　1、普利姆算法（Prim）

 　　　 基本思想：假设G＝(V，E)是连通的，TE是G上最小生成树中边的集合。算法从U＝{u0}（u0∈V）、TE＝{}开始。重复执行下列操作：

   　　  在所有u∈U，v∈V－U的边(u，v)∈E中找一条权值最小的边(u0,v0)并入集合TE中，同时v0并入U，直到V＝U为止。

   　　 此时，TE中必有n-1条边，T=(V，TE)为G的最小生成树。

  　　  Prim算法的核心:始终保持TE中的边集构成一棵生成树。

　　　注意：prim算法适合稠密图，其时间复杂度为O(n^2)，其时间复杂度与边得数目无关，而kruskal算法的时间复杂度为O(eloge)跟边的数目有关，适合稀疏图。

　　　　示例：

　　　　

 

 

　　（1）图中有6个顶点v1-v6，每条边的边权值都在图上；在进行prim算法时，我先随意选择一个顶点作为起始点，当然我们一般选择v1作为起始点，好，现在我们设U集合为当前所找到最小生成树里面的　　　顶点，TE集合为所找到的边，现在状态如下：    

　　　　　　U={v1}； TE={}；

　　（2）现在查找一个顶点在U集合中，另一个顶点在V-U集合中的最小权值，如下图，在红线相交的线上找最小值。

 　　

 

　　通过图中我们可以看到边v1-v3的权值最小为1，那么将v3加入到U集合，（v1，v3）加入到TE，状态如下：

U={v1，v3}； TE={（v1，v3）}；

（3）继续寻找，现在状态为U={v1，v3}； TE={（v1，v3）}；在与红线相交的边上查找最小值。

　　

　　我们可以找到最小的权值为（v3，v6）=4，那么我们将v6加入到U集合，并将最小边加入到TE集合，那么加入后状态如下：

　　U={v1，v3，v6}； TE={（v1，v3），（v3，v6）}； 如此循环一下直到找到所有顶点为止。

　　（4）下图像我们展示了全部的查找过程：

　　

 

　　　　

　　2、克鲁斯卡尔算法（Kruskal）

　　　　

　　假设连通网N＝（V，{E}）。则令最小生成树的初始状态为只有n个顶点而无边的非连通图T＝（V，{}），图中每个顶点自成一个连通分量。在E中选择最小代价的边，若该边依附的顶点落在T中不同的连通分　      量中，则将该边加入到T中，否则舍去此边而选择下一条代价最小的边，依次类推，直到T中所有顶点都在同一连通分量上为止。

　　示例如下：

　　

　　　　图中先将每个顶点看作独立的子图，然后查找最小权值边，这条边是有限制条件的，边得两个顶点必须不在同一个图中，如上图，第一个图中找到最小权值边为（v1，v3），且满足限制条件，继续查找边　             （v4，v6），（v2，v5），（v3，v6），当查找到最后一条边时，仅仅只有（v2，v3）满足限制条件，其他的如（v3，v4），（v1，v4）都在一个子图里面，不满足条件，至此已经找到最小生成树的

           所有边。

 

 

　　上述所有的具体代码实现：

　　

/**
 * java数据结构无向图的实现
 * 2016/4/29
 */
package cn.Link;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
public class Graph {
            
    final static int MAX = 65535;  //两个定点之间没有路径时的长度
    int verticts; //顶点数
    int sides;      //顶点为verticts的连通图的边数值 
    int[][] arc;//存储图的二维数组 
    String[] vex;
    Graph(int verticts){
        this.verticts = verticts;
        this.sides = 0;
        for(int i = verticts-1;i>0;i--){
            this.sides +=i;     //获得连通图的边数值
        }
        this.arc = new int[verticts][verticts];
        this.vex = new String[verticts];
        //初始化一个有向图，所有边设为最大权值（即不可能达到的值）
        for(int i = 0; i < verticts;i++){
            for(int j = 0; j < verticts;j++){
                if(i!=j){
                   this.arc[i][j] = MAX;
                }else{
                    this.arc[i][j]=0;
                }
                
            }
        }
    }
    
    //假设有这样一个图
    public void addGraph(){
        //顶点数据
        this.vex[0] = "beijing";
        this.vex[1] = "shanghai";
        this.vex[2] = "tianjing";
        this.vex[3] = "chengdu";
        this.vex[4] = "changsha";
        this.vex[5] = "chongqing";

        //边的权值
        for(int i = 1; i < verticts;i++){
            for(int j = 0; j < i;j++){
                int n = (int)(Math.random()*100);    //随机生成权值
                if(n > 0){
                this.arc[i][j]=this.arc[j][i] = n;
                }else if(n == 0){
                    this.arc[i][j]=this.arc[j][i] = MAX;
                }
                
            }
        }
    }

    //利用图的二维数组输出
    public void printGraph(){
        for(int i = 0; i < verticts;i++){
            //输出第一行的名称
            if(i == 0){
                System.out.print("*         ");
                for(int x=0;x<verticts;x++){
                    System.out.print(this.vex[x]+"  ");
                }
                System.out.println();
                System.out.println("         ==============================================================");
            }
            //给每行前面输出地址
                System.out.print(this.vex[i]+"     ");
            for(int j = 0; j < verticts;j++){
                System.out.print(this.arc[i][j]+"        ");
            }
            System.out.println();
            System.out.println();
        }
    }

    //深度优先遍历输出
    public void DFS(Graph G,int i,boolean[] visited){
        int j;
        visited[i] = true;
        System.out.print(G.vex[i]+"  ");   //打印顶点的值
        for(j = 0;j < G.verticts;j++){
            if(G.arc[i][j]>0 && !visited[j]){
                DFS(G,j,visited);       //对访问的邻接顶点递归调用
            }
        }
        
    }
    public void DFSTraverse(Graph  G){
        boolean[] visited = new boolean[G.verticts];
        for(int i = 0;i < G.verticts;i++){
            visited[i] = false;         //初始状态所有顶点都是未访问过的状态
        }
        for(int i = 0;i < G.verticts;i++){
            if(!visited[i])
                DFS(G,i,visited);       //对未访问过的顶点调用DFS  如果是连通图，则只会执行一次
        }
    }



    //广度优先遍历输出
    public void BFS(Graph G){
        int i, j;
        Queue<Integer> Q = new LinkedList<Integer>();
        boolean[] visited = new boolean[G.verticts];
        for(i = 0;i < G.verticts;i++){
            visited[i] = false;
        }
        
        for(i = 0; i < G.verticts;i++){       //对每一个顶点都进行循环
            if(!visited[i]){
                visited[i] = true;
                System.out.print("##"+G.vex[i]+"  ");
                Q.offer(i);
                while(Q != null){
                    if(Q.peek() != null){
                    i = Q.poll(); //将队首元素赋值给i  然后出队列
                    }else{return ;}
                    for(j = 0;j < G.verticts;j++){
                        //判断其他顶点与当前顶点存在边但未被访问过
                        if(G.arc[i][j] > 0 && !visited[j]){
                            visited[j] = true;
                            System.out.print("##"+G.vex[j]+"  ");
                            Q.offer(j);
                        }
                    }
                }
            }
        }
    }

    //得到最小生成树之普利姆（Prim）算法
    public void MiniSpanTree_Prim(Graph G){
        int min, i, j, k;
        int [] adjvex = new int[G.verticts];           //保存相关顶点下表
        int [] lowcost = new int[G.verticts];          //保存相关顶点间边的权值
        lowcost[0] = 0;                         //初始化第一个权值为0 ，即vex[0]已经加入到生成树
        adjvex[0] = 0;                          //初始化第一个顶点下标为0
        for(i = 1;i < G.verticts;i++){
            lowcost[i] = G.arc[0][i];           //将vex[0]顶点与之有边的权值存入数组
            adjvex[i] = 0;                      //初始化都为vex[0]的下标
        }

        for(i = 1;i < G.verticts;i++){
            min =  MAX;                     //初始化最小权值为MAX：65535  
            j = 1;
            k = 0;
            //循环所有顶点
            while(j < G.verticts){
                if(lowcost[j] != 0 && lowcost[j] < min){    //如果权值不为0，而且小于最小值
                    min = lowcost[j];
                    k = j;
                }
                j++;
            }

            System.out.println("("+k+", "+adjvex[k]+")"+"   权长："+G.arc[adjvex[k]][k]);        //打印当前顶点边中权值最小的边
            lowcost[k] = 0;                 //将当前顶点的权值设为0，表示此顶点已将完成任务
            for(j = 1;j < G.verticts;j++){  //循环所有顶点
                if(lowcost[j] != 0 && G.arc[k][j] < lowcost[j]){       //如果下标为k的顶点各边权值小于此前这些顶点未被加入生成权值
                    lowcost[j] = G.arc[k][j];           //将较小的权值存入lowcost
                    adjvex[j] = k;          //将下标为k的顶点存入adjvex
                }
            }
        }
    }


    //得到最小生成树之克鲁斯卡尔（Kruskal）算法
    //得到边集数组并按权由大到小排序 这一步是利用Edge类来实现的
    //注意 此函书还有错误，有时候会输出6条边，尚待解决（MinispanTree_kruskal在寻找的过程中不可能形成环路，所以不可能多一条边）
    //上述错误已经解决，有两个地方出来问题，第一：Edge的begin必须小于end，否则在Find函数中判断将出现错误，因为如果end小于begin的话，end有可能
    //出现等于0的情况，第二：循环每一条边时，i应该小于G.sides；而我之前写成了i<G.verticts
    public void MiniSpanTree_Kruskal(Graph G){
        Edge edge = new Edge(); 
        edge.Edge_1(G);
        //edge.PrintEdge();
        int i, n, m;
        int num = 0;  //记录找到了多少条边
        int parent[] = new int[G.verticts];   //定义一个数组用来判断边与边是否形成回路
        for( i = 0;i < G.verticts;i++){
            parent[i] = 0;      //初始化数组为-1
        }
        for(i = 0;i < G.sides;i++){        // 循环每一条边，15为顶点
            n = Find(parent,edge.edge[i].begin);
            m = Find(parent,edge.edge[i].end);
            if(n != m ){         //n不等于m  说明边与边没有形成环路
                parent[n] = m;//将此边的尾节点放入下标为起点的parent中
                System.out.println("("+edge.edge[i].begin+","+edge.edge[i].end+")"+"  权长："+edge.edge[i].weight);
                num++;
                //for(int j = 0;j < G.verticts;j++){
                    //System.out.print("  !!!!"+parent[j]);      //初始化数组为0
                 //}
            }
            if(num >= G.verticts)  break;     //如果找到了（顶点数-1）条边，并且没有构成回路，就已经完成任务了，不用再找了，
            
        }
    }
    public int Find(int[] parent,int f){        //查找连线顶点的尾部下表
        while(parent[f] > 0){
            f = parent[f];
        }
        return f;
    }


    //测试函数
    public static void main(String[] args){
        Graph graph = new Graph(6);  //创建一个顶点个数为6的图
        graph.addGraph();
        System.out.println("将图以二维矩阵的方式输出");
        graph.printGraph(); 
        System.out.println("深度优先搜索结果");
        graph.DFSTraverse(graph); 
        System.out.println();
        System.out.print("广度优先搜索结果");
        System.out.println();
        graph.BFS(graph);
        System.out.println();
        System.out.println("最小生成树之普利姆算法Prim  ");
        graph.MiniSpanTree_Prim(graph);
        System.out.println();
        System.out.println("最小生成树之克鲁斯卡尔算法Kruskal   ");
        graph.MiniSpanTree_Kruskal(graph);

    }
}




//Edge类  利用深度优先遍历得到树的所有路径以及这些路径的权值，并根据权值的大小进行从小到大排序
class Edge{
    public int begin;           //这两个顶点的开始顶点
    public int end;             //这两个顶点的结束顶点
    public int weight;          //两个顶点之间的权值
    Edge edge[] = new Edge[15]; //edge数组  图的边数没有传入，计算最大值
    Edge(){}
    public void Edge_1(Graph G){
        DFSTraverse_1(G);       //得到edge数组
        sortEdge();             //对dege进行排序
    }
    
    public void SetEdge(int begin,int end,int weight){
        this.begin = begin;
        this.end = end;
        this.weight = weight;
        
    }
    int k=0;        //用于数组赋值是计数
    //利用深度优先遍历得到edge数组
    public void  DFS_1(Graph G,int i,boolean[] visited){
        int j;
        
        visited[i] = true;
        //System.out.print(G.arc[i][i+1]+"  ");   //打印顶点的值
        for(j = 0;j < G.verticts;j++){
            if(G.arc[i][j]>0 && !visited[j]){
                //System.out.print(G.arc[i][j]+"  ");
                DFS_1(G,j,visited);       //对访问的邻接顶点递归调用
            }
            if(G.arc[i][j] > 0  && i > j){
                this.edge[this.k] = new Edge();
                edge[this.k].SetEdge(j,i,G.arc[i][j]);
                this.k++;
            }
            
        }
        
    }
    public void DFSTraverse_1(Graph  G){
        boolean[] visited = new boolean[G.verticts];
        for(int i = 0;i < G.verticts;i++){
            visited[i] = false;         //初始状态所有顶点都是未访问过的状态
        }
        for(int i = 0;i < G.verticts;i++){
            if(!visited[i])
                DFS_1(G,i,visited);       //对未访问过的顶点调用DFS  如果是连通图，则只会执行一次
        }
    }
    //对得到的数组进行排序
    public void sortEdge(){
        Edge newEdge = new Edge();
        newEdge.edge[0] = new  Edge();
        for(int i = 0;i < this.edge.length;i++){
            for(int j =  i;j < this.edge.length;j++){
                if(this.edge[i].weight > this.edge[j].weight){
                    newEdge.edge[0] = this.edge[i];
                    this.edge[i] = this.edge[j];
                    this.edge[j] = newEdge.edge[0];
                }
            }
        }
    }
    //输出Edge数组，用以测试Edge是否创建、赋值成功
    public void PrintEdge(){
        for(int i = 0; i < this.edge.length;i++){
            System.out.println("数组"+i+":    "+this.edge[i].begin+"  "+this.edge[i].end+"  "+this.edge[i].weight);
        }
    }
}