数据结构7——图形（图形的存储）

图具有的特点是：每个结点有零个或者多个前驱结点，并且有零个或者多个后驱结点。

图的存储方式分为邻接矩阵和邻接表。而邻接矩阵适合于稠密图中，邻接表适合于稀疏图形中。

同时图又分为：有向图，无向图。

结点与结点之间相连是为1，如果不想连则定义为零。

1：邻接矩阵

主要是邻接矩阵存储的设计方式：图的结点信息存储在线性表中，

　　　　　　　　　　　　　　   图的边权值信息存储在二维数组中。

定义一个设计图形的各种方法的类，包括对于边，结点元素的增删。

package com.hone.graph;

import com.hone.linearlist.SeqList;

public class AdjMWGraph {
    
    //定义一个全局变量当不连接的时候定义权重值
    static final int maxWeight=1000;
    
    private  SeqList vertices;                    //用顺序表来存储结点
    private int [][] edge;                        //用二维数组来存储边
    private int numOfEdges;                        //边的个数
    
    //定义一个构造函数用于初始化结点的属性，对于有n个结点的无向图，有n*n个结点可以参考
    public AdjMWGraph(int maxV){
        vertices = new SeqList(maxV);                 //创建顺序表vertices
        edge=new int[maxV][maxV];                    //创建二维数组edge
        for (int i = 0; i < maxV; i++) {
            for (int j = 0; j < maxV; j++) {
                if (i==j) {
                     edge[i][j]=0;                    //无向图顺序矩阵存储的时候对角为0
                }else{
                    edge[i][j]= maxWeight;
                }
            }
        }
        numOfEdges = 0;
    }
    
    
    //定义一个方法用于返回结点的个数
    public int  getNumOfVertices(){
        return vertices.size();
    }
    
    //定义一个方法用于返回边的个数
    public int getNumOfEdges(){
        return numOfEdges;
    }
    
    //获得结点v的数据元素
    public Object getValue(int v)throws Exception{
        return vertices.getDate(v);
    }
    
    //返回   边<v1,v2>之间的权值
    public int getWeight(int v1, int v2){
        if (v1<0||v1 >= vertices.size()||v2<0||v2>=vertices.size()) {
            System.out.println("参数越界，请输入正确的参数");
        }
        return edge[v1][v2];
    }
    
    //将 某个结点插入        调用顺序表中的插入函数    并且在顺序表的末端插入函数
    public void insetVertex(Object vertex)throws Exception{
        vertices.insert(vertices.size(), vertex);             
    }
    
    //插入边<v1,v2> 并且权值为weight
    public void insertEdge(int v1,int v2,int weight)throws Exception{
        if (v1<0||v1 >= vertices.size()||v2<0||v2>=vertices.size()) {
            System.out.println("参数越界，请输入正确的参数");
        }
        edge[v1][v2]= weight;                //重置边的权值
        numOfEdges++;                        //边的个数+1
    }
    
    //删除边<v1,v2>        在定义顺序矩阵的时候就规定权值为无穷大的时候边就不存在的，
    public void deleteEdge(int v1, int v2)throws Exception{
        if (v1<0||v1 >= vertices.size()||v2<0||v2>=vertices.size()) {
            System.out.println("参数越界，请输入正确的参数");
        }
        if (edge[v1][v2]==maxWeight||v1==v2) {
            System.out.println("该边不存在！");
        }
        edge[v1][v2]=maxWeight;                        //将边的权重设为无穷大
        numOfEdges--;
    }
    
    //取结点v的第一个邻结点，如果存在则返回结点的下标序号，否则返回-1
    public int getFirstNeighbor(int v)throws Exception{
        if (v <0||v >= vertices.size()) {
            System.out.println("参数越界，请输入正确的参数");
        }
        for (int col = 0; col <vertices.size(); col++) {
            if (edge[v][col]>0&&edge[v][col]<maxWeight) {
                return col;
            }
        }
        return -1;
    }
    
    
    //取出结点v1的邻接点v2后的邻接点，如果存在该结点则返回结点的下标值，否则返回-1
    public int getNextNeighbor(int v1,int v2)throws Exception{
        if (v1 <0||v1 >= vertices.size()||v2 <0||v2 >= vertices.size()) {
            System.out.println("参数越界，请输入正确的参数");
        }
        for (int col = v2+1; col <vertices.size(); col++) {
            if (edge[v1][col]>0&&edge[v1][col]<maxWeight) {
                return col;
            }
        }
        return -1;
    }148 }

设计一个类用于存储图新的边，以及结点信息。

package com.hone.graph.test;

import com.hone.graph.AdjMWGraph;

public class RowColWeight {
    int row;            //行下标
    int col;            //列下标
    int weight;            //权重
    
    //定义一个构造函数用于初始化参数
    public RowColWeight(int r, int c,int w){
        row=r;
        col=c;
        weight=w;
    }
    
    //static 成员函数，给参数创建AdjMWGraph类对象g,v为结点的数据元素集合，n为结点的个数，rc为边的集合，e为边的个数
    
    public static void createGraph(AdjMWGraph g, Object[] v,
            int n, RowColWeight[] rc,int e) throws Exception{
        //在图g中插入n个结点
        for(int i=0; i<n;i++){
            g.insetVertex(v[i]);
        }
        //在图g中插入e个边
        for (int j = 0; j < e; j++) {
            g.insertEdge(rc[j].row, rc[j].col, rc[j].weight);
        }
        
    }

}

测试图形的信息：

package com.hone.graph.test;

import com.hone.graph.AdjMWGraph;
import com.hone.graph.Visit;

public class TestSearch {
    
    
    public static void main(String[] args) {
        final int maxVertices=100;
        Visit vs=new Visit();
        
        AdjMWGraph graph=new AdjMWGraph(maxVertices);
        int n=5,e=5;
        //定义结点元素的集合
        Character[] a={new Character('A'),
                       new Character('B'),
                       new Character('C'),
                       new Character('D'),
                       new Character('E'),
        };
        
        RowColWeight[] rowColWeights={new RowColWeight(0, 1, 10),
                                    new RowColWeight(0, 4, 20),
                                    new RowColWeight(1, 3, 30),
                                    new RowColWeight(2, 1, 40),
                                    new RowColWeight(3, 2, 50),
                
        };
        try {
            RowColWeight.createGraph(graph, a, n, rowColWeights, e);
            System.out.println("结点的个数为："+graph.getNumOfVertices());
            System.out.println("边的个数为："+graph.getNumOfVertices()); 
            
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        
        
    }

}