并查集

并查集

并查集能很好地解决网络中两个节点是否连接的问题，但并查集不会给出节点之间的路径。正因为如此，并查集在判断节点的连通性时效率很高。其时间复杂度为O(1)。

并查集实现

思路：

• 相连的节点具有相同的id值
• 要实现p，q两个节点的合并，就需要将所有与p节点id值相同的节点的id改为q的id。

function unionFind(n){    this.id = [];    for (var i = 0; i < n; i++) {        //初始化时，每个节点的id值都不相同        this.id[i] = i;    }    this.find = function(p){        if (p >= 0 && p < this.id.length) {            return this.id[p];        }    }    this.isConnected = function(p,q){        return this.find(p) == this.find(q);    }    this.unionElements = function(p,q){        var pId = this.id[p];        var qId = this.id[q];        if (pId == qId) {            return;        }        for (var i = 0; i < this.id.length; i++) {            if (this.id[i] == pId) {                this.id[i] = qId;            }        }    }}

并查集优化（1）

思路：

• 为每个元素指定父节点， 初始化时每个元素的父节点都指向自身
• 两个元素相连可以看做是一个元素是另一个元素的父节点

function unionFind2(n){    this.parent = [];    for (var i = 0; i < n; i++) {        //初始化时父节点等于自身        this.parent[i] = i;    }    this.find = function(p){        if (p < 0 || p >= this.parent.length) {            return -1;        }        //获得元素p的根节点        while(parent[p] != p ){            p = parent[p];        }        return p;    }    this.isConnected = function(p,q){        //两个元素根节点相等即代表相连        return this.find(p) == this.find(q);    }    this.unionElements = function(p,q){        int pParent = find[p];        int qParent = find[q];        if (pParent == qParent) {            return;        }        //将一个元素的父节点设置为另一个元素，则代表两个元素相连        this.parent[pParent] = qParent;    }}

并查集优化（2）

思路：

• 如果节点之间相连所形成的树层数太高的话，查到元素的根节点所耗费的时间会增加
• 增加一个数组，用于记录以每个节点为根节点的树中子节点的数量
• 每次合并元素之前，先判断一下待合并的元素所在的根节点哪个节点数量多，将数量少的根节点的父节点设置为数量多的根节点，并维护子节点数量数组

function unionFind2(n){    this.parent = [];    this.size = [];    for (var i = 0; i < n; i++) {        this.parent[i] = i;        //初始化时，每个节点的根节点都是自身，因此，size数量都为1        this.size[i] = 1;    }    this.find = function(p){        if (p < 0 || p >= this.parent.length) {            return -1;        }        while(parent[p] != p ){            p = parent[p];        }        return p;    }    this.isConnected = function(p,q){        return this.find(p) == this.find(q);    }    this.unionElements = function(p,q){        int pParent = find[p];        int qParent = find[q];        if (pParent == qParent) {            return;        }        //合并时判断哪个分支数量多，将数量少的父节点设置为数量多的        if (this.size[pParent] > this.size[qParent]) {            this.parent[qParent] = pParent;            this.size[pParent] += this.size[qParent];        }else{            this.parent[pParent] = qParent;            this.size[qParent] += this.size[pParent];        }     }}

并查集优化（3）

思路：

• 用节点数量判断应该怎样连接两个分支是不准确的，因为节点数量不能代表一个分支的节点层数
• 用节点层数来判断怎样合并两个分支更加合理

function unionFind2(n){    this.parent = [];    //rank表示以每个节点为根节点的分支树的高度    this.rank = [];    for (var i = 0; i < n; i++) {        this.parent[i] = i;        //初始化时每个分支的高度都为1        this.rank[i] = 1;    }    this.find = function(p){        if (p < 0 || p >= this.parent.length) {            return -1;        }        while(parent[p] != p ){            p = parent[p];        }        return p;    }    this.isConnected = function(p,q){        return this.find(p) == this.find(q);    }    this.unionElements = function(p,q){        int pParent = find[p];        int qParent = find[q];        if (pParent == qParent) {            return;        }        //将层数少的分支的父节点设置为层数大的分支的父节点，此时，分支层数不会发生变化        if (this.rank[pParent] > this.rank[qParent]) {            this.parent[qParent] = pParent;        }else if(this.rank[pParent] < this.rank[qParent]){            this.parent[pParent] = qParent;        } else{            //当两个分支层数相同时，连接在一起之后，其中一个分支的层数将+1            this.parent[pParent] = qParent;            this.rank[qParent] += 1;        }    }}

并查集优化（4）

思路：

• 每一个分支的层数越小，查询的效率越高
• 在find寻找某一元素的根节点的过程中，可以同时对分支的路径进行压缩，减少分支层数

function unionFind2(n){    this.parent = [];    this.rank = [];    for (var i = 0; i < n; i++) {        this.parent[i] = i;        this.rank[i] = 1;    }    this.find = function(p){        if (p < 0 || p >= this.parent.length) {            return -1;        }        while(parent[p] != p ){            parent[p] = parent[parent[p]];//路径压缩            p = parent[p];        }        return p;    }    this.isConnected = function(p,q){        return this.find(p) == this.find(q);    }    this.unionElements = function(p,q){        int pParent = find[p];        int qParent = find[q];        if (pParent == qParent) {            return;        }        if (this.rank[pParent] > this.rank[qParent]) {            this.parent[qParent] = pParent;        }else if(this.rank[pParent] < this.rank[qParent]){            this.parent[pParent] = qParent;        } else{            this.parent[pParent] = qParent;            this.rank[qParent] += 1;        }    }}

并查集优化（5）

思路：

• 路径压缩是减少分支层数的有效方法，最理想的路径压缩效果是：在每个分支中，所有子节点的父节点都为根节点，即分支的层数为2。

function unionFind2(n){    this.parent = [];    this.rank = [];    for (var i = 0; i < n; i++) {        this.parent[i] = i;        this.rank[i] = 1;    }    this.find = function(p){        if (p < 0 || p >= this.parent.length) {            return -1;        }        //第二种路径压缩方法,通过递归的方式将所有节点的父节点都设置为根节点        if (this.parent[p] != p ) {            this.parent[p] = find(this.parent[p]);        }        return this.parent[p];    }    this.isConnected = function(p,q){        return this.find(p) == this.find(q);    }    this.unionElements = function(p,q){        int pParent = find[p];        int qParent = find[q];        if (pParent == qParent) {            return;        }        if (this.rank[pParent] > this.rank[qParent]) {            this.parent[qParent] = pParent;        }else if(this.rank[pParent] < this.rank[qParent]){            this.parent[pParent] = qParent;        } else{            this.parent[pParent] = qParent;            this.rank[qParent] += 1;        }    }}