用JAVA采用Kruskal与Prim算法求出该图的最小生成树。要求给出步骤，画出过程图。

首先，我们需要给出图的邻接矩阵表示：

      A   B   C   D   E   F   G   H   I
  A   0   4   0   0   0   0   0   8   0
  B   4   0   8   0   0   0   0   11  0
  C   0   8   0   7   0   4   0   0   2
  D   0   0   7   0   9   14  0   0   0
  E   0   0   0   9   0   10  0   0   0
  F   0   0   4   14  10  0   2   0   0
  G   0   0   0   0   0   2   0   1   6
  H   8   11  0   0   0   0   1   0   7
  I   0   0   2   0   0   0   6   7   0

接下来我们分别使用Kruskal算法和Prim算法求解该图的最小生成树。

## Kruskal算法

1. 将所有边按照权重从小到大排序
2. 从最小权重的边开始，如果加入该边不会形成环，则将该边加入生成树中
3. 重复步骤2直到所有点都已经连接

初始状态：

   A-B 4         C-H 2         D-E 9         F-G 2         G-H 1

第一步，加入C-H：

   A-B 4         D-E 9         F-G 2         G-H 1
   C-H 2

第二步，加入F-G：

   A-B 4         D-E 9         G-H 1
   C-H 2         F-G 2

第三步，加入G-H：

   A-B 4         D-E 9
   C-H 2         F-G 2         G-H 1

第四步，加入A-B：

   D-E 9
   A-B 4         C-H 2         F-G 2         G-H 1

第五步，加入D-E：

   A-B 4
   C-H 2         D-E 9         F-G 2         G-H 1

最终生成树：

   A-B 4
   C-H 2         F-G 2
   G-H 1         D-E 9

## Prim算法

1. 随便选一个点作为开始节点
2. 将与该节点相连的所有边加入优先队列
3. 取出权重最小的边，如果该边连接的点没有被访问过，则将该边加入生成树，同时将与该点相连的所有未访问过的边加入优先队列
4. 重复步骤3直到所有点都已经连接

初始状态：

   A-B 4         C-H 2         D-E 9         F-G 2         G-H 1

选择节点A作为开始节点，加入与A相连的所有边（B、H）：

   A-B 4         A-H 8

取出A-B，将B加入生成树且加入与B相连的所有边（A、C）：

   A-H 8         B-C 8         B-A 4

取出B-A，此边连接的点已经都被访问过，跳过该边：

   A-H 8         B-C 8

取出B-C，将C加入生成树且加入与C相连的所有边（B、D、I）：

   A-H 8         B-D 11        B-A 4         C-I 2         C-B 8
                        C-B 8

取出C-I，将I加入生成树且加入与I相连的所有边（C、H）：

   A-H 8         B-D 11        B-A 4         C-H 2         C-B 8         I-C 2
                        C-B 8

取出C-H，将H加入生成树且加入与H相连的所有边（A、G、I）：

   B-D 11        B-A 4         C-B 8         G-F 2         H-A 8         I-C 2

取出G-F，将F加入生成树且加入与F相连的所有边（G、E）：

   B-D 11        B-A 4         C-B 8         E-D 9         H-A 8         I-C 2         F-G 2
                                        G-E 10

取出F-G，此边连接的点已经都被访问过，跳过该边：

   B-D 11        B-A 4         C-B 8         E-D 9         H-A 8         I-C 2
                                        G-E 10

取出I-C，此边连接的点已经都被访问过，跳过该边：

   B-D 11        B-A 4         C-B 8         E-D 9         H-A 8
                                        G-E 10

取出E-D，将E加入生成树且加入与E相连的所有边（D）：

   B-A 4         C-B 8         D-E 9         H-A 8
                                        G-E 10         E-D 9

取出D-E，此边连接的点已经都被访问过，跳过该边：

   B-A 4         C-B 8         H-A 8
                                        G-E 10

最终生成树：

   A-H 8         C-B 8         E-D 9         F-G 2