如上图，这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
//www.greatytc.com/p/84452096e345

有bug欢迎指出