（20）Go实现并查集-路径压缩

如上图，这3种树结构效果都是一样的，但是时间复杂度却不相同

优化思路如上图

（5）第五版union find
特点：在第四版的基础上加入路径压缩压缩功能，每次在寻找父节点时，让该节点指向父节点的父节点，
能达到上图效果，这个时候rank代表的不再是高度，更像是一种优先级，让优先级别低的指向优先级高的。
// 实现
type unionSet struct {
	rank []int // 以数值sz[i]为根的树的深度(高度)
	set  []int
}

func NewUnionSet(size int) *unionSet {
	buf1 := make([]int, size)
	for i := 0; i < size; i++ {
		buf1[i] = i
	}
	buf2 := make([]int, size)
	for i := 0; i < size; i++ {
		buf2[i] = 1
	}

	return &unionSet{
		rank: buf2,
		set:  buf1,
	}
}

func (set *unionSet) GetSize() int {
	return len(set.set)
}

func (set *unionSet) GetID(p int) (int, error) {
	if p < 0 || p > len(set.set) {
		return 0, errors.New(
			"failed to get ID,index is illegal.")
	}

	return set.getRoot(p), nil
}

func (set *unionSet) getRoot(p int) int {
	for p != set.set[p] {
		set.set[p] = set.set[set.set[p]]
		p = set.set[p]
	}
	return p
}

func (set *unionSet) IsConnected(p, q int) (bool, error) {
	if p < 0 || p > len(set.set) || q < 0 || q > len(set.set) {
		return false, errors.New(
			"error: index is illegal.")
	}
	return set.getRoot(set.set[p]) == set.getRoot(set.set[q]), nil
}

func (set *unionSet) Union(p, q int) error {
	if p < 0 || p > len(set.set) || q < 0 || q > len(set.set) {
		return errors.New(
			"error: index is illegal.")
	}

	pRoot := set.getRoot(p)
	qRoot := set.getRoot(q)

	if pRoot != qRoot {
		if set.rank[pRoot] < set.rank[qRoot] {
			set.set[pRoot] = qRoot
		} else if set.rank[qRoot] < set.rank[pRoot] {
			set.set[qRoot] = pRoot
		} else { 
			set.set[pRoot] = qRoot
			set.rank[qRoot] += 1
		}
	}
	return nil
}

性能测试
const count = 100

func main() {
	nums := []int{}
	for i := 0; i < 1000*count; i++ {
		nums = append(nums, rand.Intn(count))
	}
	test3(nums)
	test4(nums)
	test5(nums)
}

func test3(nums []int) {
	s := unionfind4.NewUnionSet(count)
	t := time.Now()
	for i := 1; i < 1000*count; i++ {
		s.Union(nums[i-1], nums[i])
	}
	fmt.Println("第三版时间: ", t.Sub(time.Now()))
}

func test4(nums []int) {
	s := unionfind5.NewUnionSet(count)
	t := time.Now()
	for i := 1; i < 1000*count; i++ {
		s.Union(nums[i-1], nums[i])
	}
	fmt.Println("第四版时间: ", t.Sub(time.Now()))
}

func test5(nums []int) {
	s := unionfind6.NewUnionSet(count)
	t := time.Now()
	for i := 1; i < 1000*count; i++ {
		s.Union(nums[i-1], nums[i])
	}
	fmt.Println("第五版时间: ", t.Sub(time.Now()))
}
第三版时间:  -5.332042ms    第三版时间:  -2.363682ms    第三版时间:  -2.582779ms    
第四版时间:  -2.326679ms    第四版时间:  -4.479676ms    第四版时间:  -2.459556ms    
第五版时间:  -2.724722ms    第五版时间:  -2.850195ms    第五版时间:  -2.457411ms
结论：理论上有优化，实际测试性能却差不多，跟数据源关系，具体原因暂时未知，
由此可见并不是优化越多越好，第五版在set.set[p] = set.set[set.set[p]]这一步上花费了
更多的时间

并查集上一篇：Go–并查集1
https://www.jianshu.com/p/84452096e345