1. /**
2. * 图的遍历方式：深度优先遍历和广度优先遍历－》先创建图的邻接矩阵，求出某个顶点的第一个链接顶点－》如果某个顶点有好多个连通的顶点，求与之连通的第2个顶点的下一个顶点的位置
3. * －》深度优先遍历：先遍历某个顶点的第一个连通的顶点－》迭代的方式找到改顶点的下个第一个顶点
4. *
5. * @author timmy1
6. *
7. */
8. public class GraphTraverse {
10. int[][] matrix;// 矩阵
11. int MAX_WEIGHT = Integer.MAX_VALUE;
12. int size;// 顶点个数
13. boolean[] isVisted;// 标示顶点是否被访问过
15. private void createGraph(int index) {
16. size = index;
17. matrix = new int[index][index];
18. int[] a0 = { 0, 10, MAX_WEIGHT, MAX_WEIGHT, MAX_WEIGHT, 11, MAX_WEIGHT, MAX_WEIGHT, MAX_WEIGHT };
19. int[] a1 = { 10, 0, 18, MAX_WEIGHT, MAX_WEIGHT, MAX_WEIGHT, 16, MAX_WEIGHT, 12 };
20. int[] a2 = { MAX_WEIGHT, MAX_WEIGHT, 0, 22, MAX_WEIGHT, MAX_WEIGHT, MAX_WEIGHT, MAX_WEIGHT, 8 };
21. int[] a3 = { MAX_WEIGHT, MAX_WEIGHT, 22, 0, 20, MAX_WEIGHT, 24, 16, 21 };
22. int[] a4 = { MAX_WEIGHT, MAX_WEIGHT, MAX_WEIGHT, 20, 0, 26, MAX_WEIGHT, 7, MAX_WEIGHT };
23. int[] a5 = { 11, MAX_WEIGHT, MAX_WEIGHT, MAX_WEIGHT, 26, 0, 17, MAX_WEIGHT, MAX_WEIGHT };
24. int[] a6 = { MAX_WEIGHT, 16, MAX_WEIGHT, 24, MAX_WEIGHT, 17, 0, 19, MAX_WEIGHT };
25. int[] a7 = { MAX_WEIGHT, MAX_WEIGHT, MAX_WEIGHT, 16, 7, MAX_WEIGHT, 19, 0, MAX_WEIGHT };
26. int[] a8 = { MAX_WEIGHT, 12, 8, 21, MAX_WEIGHT, MAX_WEIGHT, MAX_WEIGHT, MAX_WEIGHT, 0 };
28. matrix[0] = a0;
29. matrix[1] = a1;
30. matrix[2] = a2;
31. matrix[3] = a3;
32. matrix[4] = a4;
33. matrix[5] = a5;
34. matrix[6] = a6;
35. matrix[7] = a7;
36. matrix[8] = a8;
37. }
39. // 深度优先遍历
40. public void DFS() {
41. isVisted = new boolean[size];
42. for (int j = 0; j < size; j++) {
43. if (!isVisted[j]) {
44. PrintUtil.print("访问到第：" + j + "顶点");
45. depthFirstSearch(j);
46. }
47. }
48. }
50. /**
51. * 图的深度优先算法实现
52. *
53. * @param i
54. * 标示第几个顶点
55. */
56. private void depthFirstSearch(int i) {
57. isVisted[i] = true;
58. // 先找到改顶点的第一个连通顶点下标
59. int vertex = getFirstVertex(i);
60. while (vertex != -1) {// 存在第一个连通的顶点－》是否已经访问过->没有访问过－》访问－》再以该新顶点深度遍历
61. if (!isVisted[vertex]) {
62. isVisted[vertex] = true;
63. PrintUtil.print("访问到第：" + vertex + "顶点");
64. depthFirstSearch(vertex);
65. }
66. vertex = getNextVertex(i, vertex);
67. }
68. }
70. //广度优先遍历
71. private void BFS() {
72. isVisted = new boolean[size];
73. for (int j = 0; j < size; j++) {
74. if (!isVisted[j]) {
75. PrintUtil.print("访问到第：" + j + "顶点");
76. broadFirstSearch(j);
77. }
78. }
79. }
81. /**
82. * 图的广度优先遍历实现：采用队列进行辅助，使用队列的增加和删除元素的方法－》实现思路为：先获取到某个顶点，－》该顶点第一个顶点－》第一个顶点后的顶点
83. * @param j
84. */
85. private void broadFirstSearch(int j) {
86. int firstVertex;
87. LinkedList<Integer> list = new LinkedList<Integer>();
88. isVisted[j] = true;
89. list.add(j);
91. while(!list.isEmpty()){
92. int vertex = list.removeFirst();//前面保存的顶点
93. firstVertex = getFirstVertex(vertex);//第一个顶点
95. while(firstVertex != -1){
96. if(!isVisted[firstVertex]){
97. isVisted[firstVertex] = true;
98. PrintUtil.print("访问到第：" + firstVertex+ "顶点");
99. list.add(firstVertex);
100. }
101. //拿到下一个顶点->赋值
102. firstVertex = getNextVertex(vertex, firstVertex);
103. }
104. }
105. }
107. /**
108. * 找到顶点i的第一个连通的顶点
109. *
110. * @param i
111. * @return 顶点下标，－1表示该顶点没有与之连通的顶点
112. */
113. private int getFirstVertex(int i) {
114. for (int j = 0; j < size; j++) {
115. if (matrix[i][j] > 0 && matrix[i][j] < MAX_WEIGHT) {
116. return j;
117. }
118. }
119. return -1;
120. }
122. /**
123. * 求顶点base，第index顶点后的下一个顶点
124. *
125. * @param base
126. * @param index
127. * @return
128. */
129. private int getNextVertex(int base, int index) {
130. for (int j = index + 1; j < size; j++) {
131. if (matrix[base][j] > 0 && matrix[base][j] < MAX_WEIGHT) {
132. return j;
133. }
134. }
135. return -1;
136. }
138. public static void main(String[] args) {
139. GraphTraverse graph = new GraphTraverse();
140. graph.createGraph(9);
141. // graph.DFS();
142. graph.BFS();
143. }
144. }