1 package iYou.neugle.graph;
2
3 import java.util.LinkedList;
4 import java.util.Queue;
5 import java.util.Stack;
6
7 public class MyGraph1 {
8 private MatrixGraph graph;
9
10 public MatrixGraph getGraph() {
11 return graph;
12 }
13
14 public void setGraph(MatrixGraph graph) {
15 this.graph = graph;
16 }
17
18 // 使用邻接矩阵作为存储单元
19 class MatrixGraph {
20 public int maxNum = 10;
21 public int[][] edge;
22 public boolean[] isVisited;
23 public int type;// 0表示无向图,1表示有向图
24
25 public MatrixGraph(int maxNum, int type) {
26 this.maxNum = maxNum;
27 this.type = type;
28 this.edge = new int[this.maxNum][this.maxNum];
29 this.isVisited = new boolean[this.maxNum];
30 }
31 }
32
33 public MyGraph1(int maxNum, int type) {
34 this.graph = new MatrixGraph(maxNum, type);
35 }
36
37 // 创建邻接矩阵 (带权值)
38 public void CreateMaxtrixGraph(int i1, int i2, int w) {
39 this.graph.edge[i1 - 1][i2 - 1] = w;
40 // 如果为无向图 则对称位置也要置为w
41 if (this.graph.type == 0) {
42 this.graph.edge[i2 - 1][i1 - 1] = w;
43 }
44 }
45
46 // 创建邻接矩阵 (不带权值)
47 public void CreateMaxtrixGraph(int i1, int i2) {
48 this.graph.edge[i1 - 1][i2 - 1] = 1;
49 // 如果为无向图 则对称位置也要置为1
50 if (this.graph.type == 0) {
51 this.graph.edge[i2 - 1][i1 - 1] = 1;
52 }
53 }
54
55 // 遍历邻接矩阵
56 public void OutPutMaxtrixGraph() {
57 int[][] edge = this.graph.edge;
58 for (int i = 0; i < edge.length; i++) {
59 if (i == 0) {
60 System.out.print(" ");
61 for (int j = 0; j < edge[i].length; j++) {
62 System.out.print((j + 1) + " ");
63 }
64 System.out.println();
65 }
66 System.out.print(i + 1 + " ");
67 for (int j = 0; j < edge[i].length; j++) {
68 System.out.print(edge[i][j] + " ");
69 }
70 System.out.println();
71 }
72 }
73
74 // 深度优先遍历
75 public void DFSTraverse() {
76 // 初始化
77 for (int i = 0; i < this.graph.isVisited.length; i++) {
78 this.graph.isVisited[i] = false;
79 }
80 // 采用栈的数据结构
81 Stack<Integer> stack = new Stack<>();
82 System.out.print("深度优先遍历的结果为: ");
83 for (int i = 0; i < this.graph.edge.length; i++) {
84 if (!this.graph.isVisited[i]) {
85 stack.push(i);
86 while (!stack.isEmpty()) {
87 int n = stack.pop();
88 if (!this.graph.isVisited[n]) {
89 System.out.print(n + 1 + " ");
90 } else {
91 continue;
92 }
93 this.graph.isVisited[n] = true;
94 for (int j = this.graph.edge[n].length - 1; j >= 0; j--) {
95 if (this.graph.edge[n][j] == 1) {
96 stack.push(j);
97 }
98 }
99 }
100 }
101 }
102 System.out.println();
103 }
104
105 // 广度优先遍历
106 public void BFSTraverse() {
107 // 初始化
108 for (int i = 0; i < this.graph.isVisited.length; i++) {
109 this.graph.isVisited[i] = false;
110 }
111 // 采用队列的数据结构
112 Queue<Integer> queue = new LinkedList<>();
113 System.out.print("广度优先遍历的结果为: ");
114 for (int i = 0; i < this.graph.edge.length; i++) {
115 if (!this.graph.isVisited[i]) {
116 queue.add(i);
117 while (!queue.isEmpty()) {
118 int n = queue.remove();
119 if (!this.graph.isVisited[n]) {
120 System.out.print(n + 1 + " ");
121 } else {
122 continue;
123 }
124 this.graph.isVisited[n] = true;
125 for (int j = 0; j < this.graph.edge[n].length; j++) {
126 if (this.graph.edge[n][j] == 1) {
127 queue.add(j);
128 }
129 }
130 }
131 }
132 }
133 System.out.println();
134 }
135
136 // 主函数
137 public static void main(String[] args) {
138 MyGraph1 myGraph = new MyGraph1(5, 0);
139 myGraph.CreateMaxtrixGraph(1, 2);
140 myGraph.CreateMaxtrixGraph(1, 3);
141 myGraph.CreateMaxtrixGraph(1, 5);
142 myGraph.CreateMaxtrixGraph(2, 4);
143 myGraph.CreateMaxtrixGraph(3, 5);
144 myGraph.CreateMaxtrixGraph(4, 5);
145 myGraph.OutPutMaxtrixGraph();
146 myGraph.DFSTraverse();
147 myGraph.BFSTraverse();
148 }
149 }
1 2 3 4 5
1 0 1 1 0 1
2 1 0 0 1 0
3 1 0 0 0 1
4 0 1 0 0 1
5 1 0 1 1 0
深度优先遍历的结果为: 1 2 4 5 3
广度优先遍历的结果为: 1 2 3 5 4