连通问题-快速合并法

快速合并法
思想：节点列表中每个节点初始存放的内容为本节点。节点node1和节点node2连通，那么将node1作为node2的子节点，node2作为node1的父节点，那么node1中存放的内容即为node2。所以在快速合并法中，节点node中存放的内容实际上是节点node的父节点。明白这点，针对一个连通对时，将其中一个节点作为父节点father，另一个作为子节点son，将子节点son的内容存放上father，这样做似乎是正确没有问题，但是仔细想想，son节点中存放的内容是父节点，如果有两个连通对，都是针对一个son的，那么他将有两个父节点，一个存储单元如何存放两个父节点呢？这个问题其实也是可以解决，仔细想想，如果节点node1和node2连通，那么node1中的父节点和node2的父节点肯定也是连通的，递推上去，node1的父节点的父节点....和node2的父节点的父节点....肯定也是连通的，那么在node1的父节点的父节点.....上，最头上的一个节点baseNode（即根节点），它存放的内容应该是自己（它没有父节点），这样把node1的根节点和node2的根节点连接起来（可以让node2根节点做node1根节点的子节点，也可以让node1根节点做node2根节点的子节点，这里将会进一步优化算法的地方），node1和node2就连通的了，问题就解决了。按照此规则，最终所有连通的节点都将会有一个共同的根节点（baseNode）。

伪代码：
//节点中的内容----这里假设节点个数为10的情况
int[] nodesContext = {0,1,2,3,4,5,6,7,8,9};
//连通节点对：p、q
//找到节点p的根节点i
for( i = p; i != nodesContext[i]; i = nodesContext[i]);
//找到节点q的根节点j
for( j = q; j != nodesContext[j]; j = nodesContext[j]);

//如果p和q的根节点是相同的，不必执行后续步骤，对新连通节点对重复上述步骤
if( i == j ) continue;

//节点i成为节点j的子节点
nodesContext[i] = j;

代码执行过程数据变化情况：
                               0,1,2,3,4,5,6,7,8,9                0,1,2,3,4,5,6,7,8,9   
connectNodes[0]    nodesContext(BEFORE)        nodesContext(AFTER)        p    q    i     j
1,2                          0,1,2,3,4,5,6,7,8,9                0,2,2,3,4,5,6,7,8,9             1    2    1    2
2,4                          0,2,2,3,4,5,6,7,8,9                0,2,4,3,4,5,6,7,8,9             2    4    2    4
0,8                          0,2,4,3,4,5,6,7,8,9                8,2,4,3,4,5,6,7,8,9             0    8    0    8
6,7                          8,2,4,3,4,5,6,7,8,9                8,2,4,3,4,5,7,7,8,9             6    7    6    7
7,3                          8,2,4,3,4,5,7,7,8,9                8,2,4,3,4,5,7,3,8,9             7    3    7    3
3,5                          8,2,4,3,4,5,7,3,8,9                8,2,4,5,4,5,7,3,8,9             3    5    3    5
9,1                          8,2,4,5,4,5,7,3,8,9                8,2,4,5,4,5,7,3,8,4             9    1    9    4
5,9                          8,2,4,5,4,5,7,3,8,4                8,2,4,5,4,4,7,3,8,4             5    9    5    4
9,8                          8,2,4,5,4,4,7,3,8,4                8,2,4,5,8,4,7,3,8,4             9    8    4    8

算法的分析：
    快速合并法比快速查找法好在它无需遍历节点列表，但也相应增加了追踪两节点是否连通的复杂，因为你不递推到节点node1的根节点，和node2的根节点，你是不知道它俩是否连通。这就带来负面影响，当你最终生成的树的深度较深，递推消耗的时间就会很大，这样合并的效率是否一定会比遍历节点列表快就不好说了，毕竟查找法，是可以直接知道两节点是否连通，只需看看两节点中存放的根节点是否相同，而合并法节点中存放的是父节点。

算法优化：
    接下来考虑一下如何改进快速合并法，如果要提高后续查找两节点连通性的效率，那么最好就是让最终生成的树不要太深。想到合并的过程中-“可以让node2根节点做node1根节点的子节点，也可以让node1根节点做node2根节点的子节点”，这个过程其实是可以优化，来减少生成树的深度的。当你的node1的根节点生成的树tree1，node2的根节点生成的树tree2，tree1的深度假设为5，tree2的深度为3，这时你是将tree1的根节点连到tree2根节点上，当个子节点呢？还是将tree2的根节点连接到tree1根节点上，当子节点呢？很明显，如果你将tree1的根节点连到tree2上，那么生成的树treeUnion深度为6，而将tree2的根节点连到tree1上，生成的树深度为5。所以采用一种规则：始终将深度小的树接到深度大的树上，这样能保证最后合成的树的深度是最小的。
    怎样做到将深度小的树连接到深度大的树上呢？这就需要对每棵树的深度做记录，在每颗树的根节点记录当前树的深度。
伪代码改动：
//初始所有节点的深度为1
for(i = 0; i < nodeCount; i++)//nodeCount为节点数
      deep[i] = 1;

//找到节点p的根节点i
for( i = p; i != nodesContext[i]; i = nodesContext[i]);
//找到节点q的根节点j
for( j = q; j != nodesContext[j]; j = nodesContext[j]);

if(deep[i] < deep[j])
{ nodesContext[i] = j; deep[j] = max(deep[i]+1,deep[j]); }
else
{ nodesContext[j] = i; deep[i] = max(deep[j]+1,deep[i]); }

      通过上面的优化，树的深度有很大改善，这样递推到根所花费的时间会大大减少。到此，似乎已经ok了，但是一些书籍中还提供了更好的方法，能够进一步对树的深度进行压缩，争取做到每个节点尽可能的连接到根节点上，这样递推的时间是最短的，效率也会有很大的提升。这种方法就叫做路径压缩法，路径压缩法有很多，拿个比较好理解的等分路径压缩法来对上述代码再做一次改动。
伪代码改动：
//找到节点p的根节点i
for( i = p; i != nodesContext[i]; i = nodesContext[i])
    nodesContext[i] = nodesContext[nodesContext[i]];
//找到节点q的根节点j
for( j = q; j != nodesContext[j]; j = nodesContext[j]);
    nodesContext[j] = nodesContext[nodesContext[j]];

     通过这样压缩的树，在节点数较多的情况下，基本是一颗扁平的树，查找连通性效率很高。