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

Posted 2020-09-08 大黄奔跑

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

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

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

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

 

1：邻接矩阵

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

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

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

  1 package com.hone.graph;
  2 
  3 import com.hone.linearlist.SeqList;
  4 
  5 public class AdjMWGraph {
  6     
  7     //定义一个全局变量当不连接的时候定义权重值
  8     static final int maxWeight=1000;
  9     
 10     private  SeqList vertices;                    //用顺序表来存储结点
 11     private int [][] edge;                        //用二维数组来存储边
 12     private int numOfEdges;                        //边的个数
 13     
 14     //定义一个构造函数用于初始化结点的属性，对于有n个结点的无向图，有n*n个结点可以参考
 15     public AdjMWGraph(int maxV){
 16         vertices = new SeqList(maxV);                 //创建顺序表vertices
 17         edge=new int[maxV][maxV];                    //创建二维数组edge
 18         for (int i = 0; i < maxV; i++) {
 19             for (int j = 0; j < maxV; j++) {
 20                 if (i==j) {
 21                      edge[i][j]=0;                    //无向图顺序矩阵存储的时候对角为0
 22                 }else{
 23                     edge[i][j]= maxWeight;
 24                 }
 25             }
 26         }
 27         numOfEdges = 0;
 28     }
 29     
 30     
 31     //定义一个方法用于返回结点的个数
 32     public int  getNumOfVertices(){
 33         return vertices.size();
 34     }
 35     
 36     //定义一个方法用于返回边的个数
 37     public int getNumOfEdges(){
 38         return numOfEdges;
 39     }
 40     
 41     //获得结点v的数据元素
 42     public Object getValue(int v)throws Exception{
 43         return vertices.getDate(v);
 44     }
 45     
 46     //返回   边<v1,v2>之间的权值
 47     public int getWeight(int v1, int v2){
 48         if (v1<0||v1 >= vertices.size()||v2<0||v2>=vertices.size()) {
 49             System.out.println("参数越界，请输入正确的参数");
 50         }
 51         return edge[v1][v2];
 52     }
 53     
 54     //将 某个结点插入        调用顺序表中的插入函数    并且在顺序表的末端插入函数
 55     public void insetVertex(Object vertex)throws Exception{
 56         vertices.insert(vertices.size(), vertex);             
 57     }
 58     
 59     //插入边<v1,v2> 并且权值为weight
 60     public void insertEdge(int v1,int v2,int weight)throws Exception{
 61         if (v1<0||v1 >= vertices.size()||v2<0||v2>=vertices.size()) {
 62             System.out.println("参数越界，请输入正确的参数");
 63         }
 64         edge[v1][v2]= weight;                //重置边的权值
 65         numOfEdges++;                        //边的个数+1
 66     }
 67     
 68     //删除边<v1,v2>        在定义顺序矩阵的时候就规定权值为无穷大的时候边就不存在的，
 69     public void deleteEdge(int v1, int v2)throws Exception{
 70         if (v1<0||v1 >= vertices.size()||v2<0||v2>=vertices.size()) {
 71             System.out.println("参数越界，请输入正确的参数");
 72         }
 73         if (edge[v1][v2]==maxWeight||v1==v2) {
 74             System.out.println("该边不存在！");
 75         }
 76         edge[v1][v2]=maxWeight;                        //将边的权重设为无穷大
 77         numOfEdges--;
 78     }
 79     
 80     //取结点v的第一个邻结点，如果存在则返回结点的下标序号，否则返回-1
 81     public int getFirstNeighbor(int v)throws Exception{
 82         if (v <0||v >= vertices.size()) {
 83             System.out.println("参数越界，请输入正确的参数");
 84         }
 85         for (int col = 0; col <vertices.size(); col++) {
 86             if (edge[v][col]>0&&edge[v][col]<maxWeight) {
 87                 return col;
 88             }
 89         }
 90         return -1;
 91     }
 92     
 93     
 94     //取出结点v1的邻接点v2后的邻接点，如果存在该结点则返回结点的下标值，否则返回-1
 95     public int getNextNeighbor(int v1,int v2)throws Exception{
 96         if (v1 <0||v1 >= vertices.size()||v2 <0||v2 >= vertices.size()) {
 97             System.out.println("参数越界，请输入正确的参数");
 98         }
 99         for (int col = v2+1; col <vertices.size(); col++) {
100             if (edge[v1][col]>0&&edge[v1][col]<maxWeight) {
101                 return col;
102             }
103         }
104         return -1;
105     }148 }

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

 1 package com.hone.graph.test;
 2 
 3 import com.hone.graph.AdjMWGraph;
 4 
 5 public class RowColWeight {
 6     int row;            //行下标
 7     int col;            //列下标
 8     int weight;            //权重
 9     
10     //定义一个构造函数用于初始化参数
11     public RowColWeight(int r, int c,int w){
12         row=r;
13         col=c;
14         weight=w;
15     }
16     
17     //static 成员函数，给参数创建AdjMWGraph类对象g,v为结点的数据元素集合，n为结点的个数，rc为边的集合，e为边的个数
18     
19     public static void createGraph(AdjMWGraph g, Object[] v,
20             int n, RowColWeight[] rc,int e) throws Exception{
21         //在图g中插入n个结点
22         for(int i=0; i<n;i++){
23             g.insetVertex(v[i]);
24         }
25         //在图g中插入e个边
26         for (int j = 0; j < e; j++) {
27             g.insertEdge(rc[j].row, rc[j].col, rc[j].weight);
28         }
29         
30     }
31 
32 }

测试图形的信息：

 1 package com.hone.graph.test;
 2 
 3 import com.hone.graph.AdjMWGraph;
 4 import com.hone.graph.Visit;
 5 
 6 public class TestSearch {
 7     
 8     
 9     public static void main(String[] args) {
10         final int maxVertices=100;
11         Visit vs=new Visit();
12         
13         AdjMWGraph graph=new AdjMWGraph(maxVertices);
14         int n=5,e=5;
15         //定义结点元素的集合
16         Character[] a={new Character(\'A\'),
17                        new Character(\'B\'),
18                        new Character(\'C\'),
19                        new Character(\'D\'),
20                        new Character(\'E\'),
21         };
22         
23         RowColWeight[] rowColWeights={new RowColWeight(0, 1, 10),
24                                     new RowColWeight(0, 4, 20),
25                                     new RowColWeight(1, 3, 30),
26                                     new RowColWeight(2, 1, 40),
27                                     new RowColWeight(3, 2, 50),
28                 
29         };
30         try {
31             RowColWeight.createGraph(graph, a, n, rowColWeights, e);
32             System.out.println("结点的个数为："+graph.getNumOfVertices());
33             System.out.println("边的个数为："+graph.getNumOfVertices()); 
37             
38         } catch (Exception e1) {
39             e1.printStackTrace();
40         }
41         
42         
43     }
44 
45 }