图论

一、图的常用概念

　　1、顶点（vertex）

　　2、边（edge）

　　3、路径

　　4、无向图：顶点之间的连接没有方向

　　5、有向图：有方向

　　6、带全图

二、图的表示方式

　　图的表示方式有两种：二维数组（邻接矩阵），链表（邻接表）

　　1、邻接矩阵

　　邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵的row和col表示的是1-n个点

　　2、邻接表

　　邻接矩阵需要为每个顶点都分配n个边的空间，其实很多边都是不存在，会造成空间的浪费

　　邻接表的实现只关心存在的边，不关心不存在的边。因此没有浪费空间，邻接表由数组+链表组成

三、深度优先遍历（Depth First Search）

　　深度优先遍历基本思想：

深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点，可以这样理解：每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。
我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。
显然，深度优先搜索是一个递归的过程

　　深度优先遍历步骤：

访问初始结点v，并标记结点v为已访问。
查找结点v的第一个邻接结点w。
若w存在，则继续执行4，如果w不存在，则回到第1步，将从v的下一个结点继续。
若w未被访问，对w进行深度优先遍历递归（即把w当做另一个v，然后进行步骤123）。
查找结点v的w邻接结点的下一个邻接结点，转到步骤3

　　代码实现：

 1     private void dfs() {
 2         isVisited = new boolean[vertexList.size()];
 3         for (int i = 0; i < vertexList.size(); i++) {
 4             if (!isVisited[i]){
 5                 dfs(isVisited,i);
 6             }
 7         }
 8     }
 9     //深度优先遍历算法
10     //i 第一次就是 0
11     private void dfs(boolean[] isVisited, int i) {
12         //输出，访问的结点
13         System.out.println(vertexList.get(i)+"->");
14         //将结点设置为已访问过
15         isVisited[i] = true;
16         //查找结点i的第一个领结节点w
17         int w = getFirstNeighbor(i);
18         while (w!=-1){
19             if (!isVisited[w]){
20                 dfs(isVisited,w);
21             }
22             //如果w结点已经被访问过
23             w=getNextNeighbor(i,w);
24         }
25     }

四、广度优先遍历（Broad First Search）

　　广度优先遍历基本思想：

　　类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点

　　深度优先遍历顺序为 1->2->4->8->5->3->6->7
　　广度优先算法的遍历顺序为：1->2->3->4->5->6->7->8

　　广度优先遍历步骤：

访问初始结点v并标记结点v为已访问。
结点v入队列
当队列非空时，继续执行，否则算法结束。
出队列，取得队头结点u。
查找结点u的第一个邻接结点w。
若结点u的邻接结点w不存在，则转到步骤3；否则循环执行以下三个步骤：

　　　　6.1 若结点w尚未被访问，则访问结点w并标记为已访问。
　　　　6.2 结点w入队列
　　　　6.3 查找结点u的继w邻接结点后的下一个邻接结点w，转到步骤6。

　　代码：

 1  private void bfs() {
 2         isVisited = new boolean[vertexList.size()];
 3         for (int i = 0; i < vertexList.size(); i++) {
 4             if (!isVisited[i]){
 5                 bfs(isVisited,i);
 6             }
 7         }
 8     }
 9 
10     private void bfs(boolean[] isVisited, int i) {
11         int u;//表示队列的头结点对应下标
12         int w;//邻接节点w
13 
14         //记录节点的访问顺序
15         LinkedList queue = new LinkedList();
16         System.out.println(vertexList.get(i)+"=>");
17         isVisited[i] = true;
18         queue.addLast(i);
19 
20         while (!queue.isEmpty()){
21             //取出队列的头结点下标
22             u= (int) queue.removeFirst();
23             //得到第一个邻接点的下标w
24             w=getFirstNeighbor(u);
25             while (w!=-1){//找到
26                 if(!isVisited[w]){
27                     System.out.println(vertexList.get(w)+"=>");
28                     isVisited[w] = true;
29                     queue.addLast(w);
30                 }
31                 //以u为前驱点，找w后面的下一个邻接点
32                 w=getNextNeighbor(u,w);
33             }
34         }
35     }

五、完整代码

  1 public class Graph {
  2 
  3     //存储顶点集合
  4     private ArrayList<String> vertexList;
  5     //存储图对应的邻接矩阵
  6     private int[][] edges;
  7     //表示边的数目
  8     private int numOfEdges;
  9     //定义给数组boolean【】，记录某个结点是否被访问过
 10     private boolean[] isVisited;
 11 
 12     public Graph(int n) {
 13         edges = new int[n][n];
 14         vertexList = new ArrayList<>(n);
 15         numOfEdges = 0;
 16     }
 17 
 18     public static void main(String[] args) {
 19 
 20         int n = 5;//结点个数
 21 //        String vertexs[] = {"1", "2", "3", "4", "5", "6", "7", "8"};
 22         String vertexs[] = {"A", "B", "C", "D", "E"};
 23         //创建图对象
 24         Graph graph = new Graph(n);
 25         for (String vertex : vertexs) {
 26             graph.insertVertex(vertex);
 27         }
 28         //更新边的关系
 29 //        graph.insertEdge(0, 1, 1);
 30 //        graph.insertEdge(0, 2, 1);
 31 //        graph.insertEdge(1, 3, 1);
 32 //        graph.insertEdge(1, 4, 1);
 33 //        graph.insertEdge(3, 7, 1);
 34 //        graph.insertEdge(4, 7, 1);
 35 //        graph.insertEdge(2, 5, 1);
 36 //        graph.insertEdge(2, 6, 1);
 37 //        graph.insertEdge(5, 6, 1);
 38         graph.insertEdge(0, 1, 1);
 39         graph.insertEdge(0, 2, 1);
 40         graph.insertEdge(1, 3, 1);
 41         graph.insertEdge(1, 2, 1);
 42         graph.insertEdge(1, 4, 1);
 43         graph.showGraph();
 44 
 45         System.out.println("深度遍历");
 46         graph.dfs();
 47         System.out.println("广度优先");
 48         graph.bfs();
 49     }
 50 
 51     private void dfs() {
 52         isVisited = new boolean[vertexList.size()];
 53         for (int i = 0; i < vertexList.size(); i++) {
 54             if (!isVisited[i]){
 55                 dfs(isVisited,i);
 56             }
 57         }
 58     }
 59     //深度优先遍历算法
 60     //i 第一次就是 0
 61     private void dfs(boolean[] isVisited, int i) {
 62         //输出，访问的结点
 63         System.out.println(vertexList.get(i)+"->");
 64         //将结点设置为已访问过
 65         isVisited[i] = true;
 66         //查找结点i的第一个领结节点w
 67         int w = getFirstNeighbor(i);
 68         while (w!=-1){
 69             if (!isVisited[w]){
 70                 dfs(isVisited,w);
 71             }
 72             //如果w结点已经被访问过
 73             w=getNextNeighbor(i,w);
 74         }
 75     }
 76 
 77     //得到第一个邻接节点的下标w
 78     //如果存在就返回对应的下标，否则返回-1
 79     private int getFirstNeighbor(int i) {
 80         for (int j = 0; j < vertexList.size(); j++) {
 81             if (edges[i][j]>0){
 82                 return j;
 83             }
 84         }
 85         return -1;
 86     }
 87     //根据前一个邻接结点的下标来获取下一个邻接结点
 88     public int getNextNeighbor(int v1, int v2) {
 89         for (int i = v2+1; i < vertexList.size(); i++) {
 90             if (edges[v1][i]>0){
 91                 return  i;
 92             }
 93         }
 94         return  -1;
 95     }
 96 
 97 
 98     private void bfs() {
 99         isVisited = new boolean[vertexList.size()];
100         for (int i = 0; i < vertexList.size(); i++) {
101             if (!isVisited[i]){
102                 bfs(isVisited,i);
103             }
104         }
105     }
106 
107     private void bfs(boolean[] isVisited, int i) {
108         int u;//表示队列的头结点对应下标
109         int w;//邻接节点w
110 
111         //记录节点的访问顺序
112         LinkedList queue = new LinkedList();
113         System.out.println(vertexList.get(i)+"=>");
114         isVisited[i] = true;
115         queue.addLast(i);
116 
117         while (!queue.isEmpty()){
118             //取出队列的头结点下标
119             u= (int) queue.removeFirst();
120             //得到第一个邻接点的下标w
121             w=getFirstNeighbor(u);
122             while (w!=-1){//找到
123                 if(!isVisited[w]){
124                     System.out.println(vertexList.get(w)+"=>");
125                     isVisited[w] = true;
126                     queue.addLast(w);
127                 }
128                 //以u为前驱点，找w后面的下一个邻接点
129                 w=getNextNeighbor(u,w);
130             }
131         }
132     }
133 
134     //显示图对应的矩阵
135     public void showGraph() {
136         for (int[] link : edges) {
137             System.out.println(Arrays.toString(link));
138         }
139     }
140 
141     /**
142      * @param v1     表示点的下标即使第几个顶点  "A"-"B" "A"->0 "B"->1
143      * @param v2     第二个顶点对应的下标
144      * @param weight 表示
145      */
146     private void insertEdge(int v1, int v2, int weight) {
147         edges[v1][v2] = weight;
148         edges[v2][v1] = weight;
149         numOfEdges++;
150     }
151 
152     private void insertVertex(String vertex) {
153         vertexList.add(vertex);
154     }
155 }

posted @ 2019-09-23 19:29 hyunbar 阅读(308) 评论(0) 编辑收藏举报

刷新页面返回顶部

hyunbar

图论

一、图的常用概念

二、图的表示方式

1、邻接矩阵

2、邻接表

三、深度优先遍历（Depth First Search）

深度优先遍历基本思想：

深度优先遍历步骤：

代码实现：

四、广度优先遍历（Broad First Search）

广度优先遍历基本思想：

广度优先遍历步骤：

代码：

五、完整代码

公告

　　1、邻接矩阵

　　2、邻接表

　　深度优先遍历基本思想：

　　深度优先遍历步骤：

　　代码实现：

　　广度优先遍历基本思想：

　　广度优先遍历步骤：

　　代码：