2. 程式人生 > >資料結構-並查集

資料結構-並查集

阿新 • • 發佈：2018-12-15

並查集

  • 一種特殊的樹, 由子節點執行父節點
  • 方便解決連線問題

主要操作

union(p,q)

用於合併p, q所在的集合

isConnected(p,q)

判斷p,q是否相連

程式碼實現

首先先定義並查集的介面, 介面定義如下:

package tree.uf;

/**
 * 並查集介面
 * @author 七夜雪
 *
 */
public interface UF {
	/**
	 *  合併p,q兩個節點
	 * @param p
	 * @param q
	 */
	public void union(int p, int q);
	/**
	 *  判斷p,q兩個節點是否相連
	 * @param p
	 * @param q
	 * @return
	 */
 

	public boolean isConnected(int p, int q);
	
    // 獲取並查集中資料數量
	public int getSize();
}

基於陣列的並查集實現

  • 使用一組陣列儲存並查集的資料

  • 陣列的索引表示資料的編號

  • 陣列的值表示資料所屬的集合, 具有相同值的資料表示在同一個集合, 如下圖所示: 1539353820817 程式碼實現如下 :

package tree.uf;

/**
 * 第一版並查集, quick-sort方式實現
 * 查詢時間複雜度O(1)
 * union時間複雜度O(n)
 * 使用陣列實現並查集:
 * 		陣列下標表示並查集id
 * 		陣列值表示並查集所屬的集合
 * @author 七夜雪
 *
 */
 

public class UnionFind1 implements UF {
	private int[] id;
	
	public UnionFind1(int size) {
		this.id = new int[size];
		for (int i = 0; i < size; i++) {
			id[i] = i;
		}
	}
	
	/**
	 * 合併兩個節點
	 * 合併兩個節點之後, 表示這兩個節點相連了
	 * 同樣的, 這兩個節點的所有其他元素也都相連了
	 * 所以可以認為兩個節點合併之後, 就是把這兩個節點所在的集合合併成一個集合
	 */
	@Override
 

	public void union(int p, int q) {
		int pid = find(p);
		int qid = find(q);
		if (pid == qid) {
			return;
		}
		
		for (int i = 0; i < id.length; i++) {
			if (find(i) != pid) {
				id[i] = pid;
			}
		}
		
	}
	
	/**
	 * 判斷節點p和節點q是否相連
	 * p,q屬於一個集合時, 表示p,q相連
	 */
	@Override
	public boolean isConnected(int p, int q) {
		return find(p) == find(q) ;
	}
	
	/**
	 * 查詢節點p所屬的集合
	 * @param p
	 * @return
	 */
	private int find(int p) {
		if (p < 0 || p >= id.length) {
			throw new IllegalArgumentException("節點id越界");
		}
		return id[p];
	}
	
	
	@Override
	public int getSize() {
		return id.length ;
	}
	
}

基於樹的並查集實現

  • 將每個元素, 看做一個節點

  • 由子節點指向父節點, 根節點指向自身

  • 具有相同根節點的兩個節點之間是相連的

  • 兩個節點合併時將其中一個節點所在樹的根節點指向另一個節點所在樹的根節點即可

    ![1539354395872](../../../%E7%9F%A5%E8%

    上圖中567三個幾點所在的集合與123三個節點所在的集合進行union操作時, 只需要將567所在的樹的根節點5指向123所在的根節點2, 或者將2指向5即可

雖然是基於樹實現並查集, 但是由於每個節點都只有一個父節點, 所以依然可以使用陣列表示並查集中的資料, 表示方式如下 :

  • 使用陣列的下標表示資料的編號

  • 陣列的值表示該節點對應的父節點的陣列下標值, 初始時將自己指向自己, 表示每個資料都是一個單獨的集合,下圖就是使用陣列演示基於樹實現並查集的union操作

    1539355642538

  • 進行查詢時, 當陣列的下標值等於陣列的值時, 表示該節點為根節點, 如parent[8] == 8, 所以8是根節點

具體程式碼如下 :

package tree.uf;

/**
 * 第二版並查集, quick-union方式實現
 * 使用樹來實現並查集
 * 將陣列組織成樹的形式, 每個節點都指向一個父節點, 根節點指向自己
 * 使用陣列索引表示當前節點位置, 陣列值表示父節點索引位置
 * 
 * 查詢和union操作時間複雜度都是O(h), h表示樹高度
 * @author 七夜雪
 *
 */
public class UnionFind2 implements UF {
	private int[] parent;
	
	public UnionFind2(int size) {
		this.parent = new int[size];
		for (int i = 0; i < size; i++) {
			parent[i] = i;
		}
	}
	
	/**
	 * 合併兩個節點
	 * 合併兩個節點之後, 表示這兩個節點相連了
	 * 同樣的, 這兩個節點的所有其他元素也都相連了
	 * 所以可以認為兩個節點合併之後, 就是把這兩個節點所在的集合合併成一個集合
	 * 合併方式:
	 * 		找到節點p的根節點, 將p的根節點指向q的根節點
	 * 
	 */
	@Override
	public void union(int p, int q) {
		// p的根節點
		int pRoot = find(p);
		// q的根節點
		int qRoot = find(q);
		if (pRoot == qRoot) {
			return;
		}
		
		// 將p的根節點指向q的根節點
		parent[pRoot] = qRoot;
	}
	
	/**
	 * 判斷節點p和節點q是否相連
	 * p,q屬於一個集合時, 表示p,q相連, 這裡表示p,q有一個共同的根節點
	 */
	@Override
	public boolean isConnected(int p, int q) {
		return find(p) == find(q) ;
	}
	
	/**
	 * 查詢節點p所屬的跟節點
	 * @param p
	 * @return
	 */
	private int find(int p) {
		if (p < 0 || p >= parent.length) {
			throw new IllegalArgumentException("節點id越界");
		}
		while(p != parent[p]){
			p = parent[p];
		}
		return p;
	}
	
	
	@Override
	public int getSize() {
		return parent.length ;
	}
	
}

基於size的優化

針對上一個版本的並查集, 存在一個問題, 每次都是隨機合併的, 會存在資料量大的集合向資料量小的集合進行合併, 會導致合併後的樹高度比較高, 如果每次合併的時候, 都是資料量較小的集合往資料量較大的集合合併的話, 會使合併後的集合的樹的高度沒有那麼高, 效能會有一定提高, 優化後代碼如下 :

package tree.uf;

/**
 * 第三版並查集, 記錄每個根節點所在的樹的節點數量, 合併時數量少的樹合併到數量多的樹上面
 * 使用樹來實現並查集
 * 將陣列組織成樹的形式, 每個節點都指向一個父節點, 根節點指向自己
 * 使用陣列索引表示當前節點位置, 陣列值表示父節點索引位置
 * 
 * 查詢和union操作時間複雜度都是O(h), h表示樹高度
 * @author 七夜雪
 *
 */
public class UnionFind3 implements UF {
	private int[] parent;
	// 下標為對應根節點下標, 陣列值為對應根節點對應樹的節點數量
	private int[] sz;
	
	public UnionFind3(int size) {
		this.parent = new int[size];
		this.sz = new int[size];
		for (int i = 0; i < size; i++) {
			parent[i] = i;
			sz[i] = 1;
		}
	}
	
	/**
	 * 合併兩個節點
	 * 合併兩個節點之後, 表示這兩個節點相連了
	 * 同樣的, 這兩個節點的所有其他元素也都相連了
	 * 所以可以認為兩個節點合併之後, 就是把這兩個節點所在的集合合併成一個集合
	 * 合併方式:
	 * 		找到節點p的根節點, 將p的根節點指向q的根節點
	 * 
	 */
	@Override
	public void union(int p, int q) {
		// p的根節點
		int pRoot = find(p);
		// q的根節點
		int qRoot = find(q);
		if (pRoot == qRoot) {
			return;
		}
		
		if (sz[pRoot] < sz[qRoot]) {
			// 將p的根節點指向q的根節點
			parent[pRoot] = qRoot;
			 sz[qRoot]+= sz[pRoot];
		} else {
			// 將q的根節點指向p的根節點
			parent[qRoot] = pRoot;
			sz[pRoot]+= sz[qRoot];
		}
	}
	
	/**
	 * 判斷節點p和節點q是否相連
	 * p,q屬於一個集合時, 表示p,q相連, 這裡表示p,q有一個共同的根節點
	 */
	@Override
	public boolean isConnected(int p, int q) {
		return find(p) == find(q) ;
	}
	
	/**
	 * 查詢節點p所屬的跟節點
	 * @param p
	 * @return
	 */
	private int find(int p) {
		if (p < 0 || p >= parent.length) {
			throw new IllegalArgumentException("節點id越界");
		}
		while(p != parent[p]){
			p = parent[p];
		}
		return p;
	}
	
	
	@Override
	public int getSize() {
		return parent.length ;
	}
	
}

基於rank的優化

上面的優化其實並不是很精確, 僅僅考慮集合元素數量, 有時候樹的元素數量,和高度並不一致, 如下圖所示, 對4,2進行合併時, 按照上面的邏輯會將節點8指向節點7, 事實上節點7指向節點8的話, 效果會更好一點, 這個時候就可以根據樹的高度進行合併操作, 而不是單單考慮集合元素數量.

1539397493967

程式碼實現如下:

package tree.uf;

/**
 * 第四版並查集, 對比第三版, 將合併時以兩個數節點數量為標準改為了以樹高度為標準
 * 
 * 查詢和union操作時間複雜度都是O(h), h表示樹高度
 * @author 七夜雪
 *
 */
public class UnionFind4 implements UF {
	private int[] parent;
	// 下標為對應根節點下標, 陣列值為對應根節點對應樹的高度
	private int[] rank;
	
	public UnionFind4(int size) {
		this.parent = new int[size];
		this.rank = new int[size];
		for (int i = 0; i < size; i++) {
			parent[i] = i;
			rank[i] = 1;
		}
	}
	
	/**
	 * 合併兩個節點
	 * 合併兩個節點之後, 表示這兩個節點相連了
	 * 同樣的, 這兩個節點的所有其他元素也都相連了
	 * 所以可以認為兩個節點合併之後, 就是把這兩個節點所在的集合合併成一個集合
	 * 合併方式:
	 * 		找到節點p的根節點, 將p的根節點指向q的根節點
	 * 
	 */
	@Override
	public void union(int p, int q) {
		// p的根節點
		int pRoot = find(p);
		// q的根節點
		int qRoot = find(q);
		if (pRoot == qRoot) {
			return;
		}
		
		if (rank[pRoot] < rank[qRoot]) {
			// 將p的根節點指向q的根節點
			parent[pRoot] = qRoot;
		} else if(rank[pRoot] > rank[qRoot]) {
			// 將q的根節點指向p的根節點
			parent[qRoot] = pRoot;
		} else {
			parent[qRoot] = pRoot;
			rank[pRoot] = rank[pRoot] + 1; 
		}
	}
	
	/**
	 * 判斷節點p和節點q是否相連
	 * p,q屬於一個集合時, 表示p,q相連, 這裡表示p,q有一個共同的根節點
	 */
	@Override
	public boolean isConnected(int p, int q) {
		return find(p) == find(q) ;
	}
	
	/**
	 * 查詢節點p所屬的跟節點
	 * @param p
	 * @return
	 */
	private int find(int p) {
		if (p < 0 || p >= parent.length) {
			throw new IllegalArgumentException("節點id越界");
		}
		while(p != parent[p]){
			p = parent[p];
		}
		return p;
	}
	
	
	@Override
	public int getSize() {
		return parent.length ;
	}
	
}

路徑壓縮

經過上述優化之後, 雖然儘量避免了樹的高度不平衡問題, 但是極端情況下, 仍然會出現樹的高度較高的情況, 在這種情況下, 可以進行路徑壓縮操作, 即每次合併時, 對路徑進行壓縮, 如下圖所示: 1539397922926

這裡可以簡單的使用parent[p] = parent[parent[p]], 即每次都將該節點指向其父節點的父節點的方式簡單的進行壓縮操作, 具體程式碼實現如下 :

package tree.uf;

/**
 * 第五版並查集, 對比第四版, 在find時,添加了路徑壓縮
 * 同時rank不在實際表示樹的高度了,只是用來標識高度大小
 * 
 * @author 七夜雪
 *
 */
public class UnionFind5 implements UF {
	private int[] parent;
	// 下標為對應根節點下標, 陣列值為對應根節點對應樹的高度, 
	// 壓縮之後不再表示樹的高度了, 但是還可以用來標示樹的高度大小, 所以這裡用rank, 不是height
	private int[] rank;
	
	public UnionFind5(int size) {
		this.parent = new int[size];
		this.rank = new int[size];
		for (int i = 0; i < size; i++) {
			parent[i] = i;
			rank[i] = 1;
		}
	}
	
	/**
	 * 合併兩個節點
	 * 合併兩個節點之後, 表示這兩個節點相連了
	 * 同樣的, 這兩個節點的所有其他元素也都相連了
	 * 所以可以認為兩個節點合併之後, 就是把這兩個節點所在的集合合併成一個集合
	 * 合併方式:
	 * 		找到節點p的根節點, 將p的根節點指向q的根節點
	 * 
	 */
	@Override
	public void union(int p, int q) {
		// p的根節點
		int pRoot = find(p);
		// q的根節點
		int qRoot = find(q);
		if (pRoot == qRoot) {
			return;
		}
		
		if (rank[pRoot] < rank[qRoot]) {
			// 將p的根節點指向q的根節點
			parent[pRoot] = qRoot;
		} else if(rank[pRoot] > rank[qRoot]) {
			// 將q的根節點指向p的根節點
			parent[qRoot] = pRoot;
		} else {
			parent[qRoot] = pRoot;
			rank[pRoot] = rank[pRoot] + 1; 
		}
	}
	
	/**
	 * 判斷節點p和節點q是否相連
	 * p,q屬於一個集合時, 表示p,q相連, 這裡表示p,q有一個共同的根節點
	 */
	@Override
	public boolean isConnected(int p, int q) {
		return find(p) == find(q) ;
	}
	
	/**
	 * 查詢節點p所屬的跟節點
	 * @param p
	 * @return
	 */
	private int find(int p) {
		if (p < 0 || p >= parent.length) {
			throw new IllegalArgumentException("節點id越界");
		}
		while(p != parent[p]){
			parent[p] = parent[parent[p]];
			p = parent[p];
		}
		return p;
	}
	
	
	@Override
	public int getSize() {
		return parent.length ;
	}
	
}

相關推薦

【資料結構並查集】POJ1988——線樹上的帶權並查集

問題描述： 給定30000個方塊，一開始每個方塊各自一摞，每次有兩種操作的方法，一種是將含有編號xx的一摞放在含有編號yy的一摞上，另一種是統計編號xx的方塊下有幾個方塊，每次將第二種操作的結果

資料結構-並查集

並查集 一種特殊的樹, 由子節點執行父節點 方便解決連線問題 主要操作 union(p,q) 用於合併p, q所在的集合 isConnected(p,q) 判斷p,q是否相連 程式碼實現 首先先定義並查集的介面, 介面定義如下: package tr

資料結構——並查集Union Find

一、並查集解決了什麼問題？ 1、網路中節點間的連線狀態：這裡的網路是一個抽象的概念，指的是使用者之間形成的網路 2、兩個或兩個以上集合之間的交集 二、對並查集的設計 對於一組資料，主要支援兩個操作 public interface UnionFind {

資料結構——並查集

等價關係：滿足自反，對稱，傳遞。 等價類：指相互等價的元素的最大集合。一個元素只能屬於一個等價類。 離線等價類問題中，已知n和R,確定所有的等價類。 線上等價類問題中，初始時有n個元素，每個元素都屬於一個獨立的等價類。 find(element)返回所屬的等價類。union

資料結構----並查集Java

並查集：(union-find sets)是一種簡單的用途廣泛的集合. 並查集是若干個不相交集合，能夠實現較快的合併和判斷元素所在集合的操作，應用很多。 應用場景： 網路連線判斷： 如果每個pair中的兩個整數分別代表一個網路節點，那麼該pair就是

POJ 1182 食物鏈 [資料結構-並查集 union-find sets]

   在輸入時可以先判斷題目所說的條件2和3,即:       1>若(x>n||y>n):即當前的話中x或y比n大,則假話數目num加1.       2>若(x==2&&x==y):即當前的話表示x吃x,則假話數目num加1.   而不屬於這兩種情況外的話語要利用

ACM-資料結構-並查集

ACM競賽中，並查集（DisjointSets）這個資料結構經常使用。顧名思義，並查集即表示集合，並且支援快速查詢、合併操作。 並查集如何表示一個集合？它藉助樹的思想，將一個集合看成一棵有根樹。那又如何表示一棵樹？初始狀態下，一個元素即一棵樹，根即是元素本身。 並查集如何

資料結構--並查集的原理及實現

一，並查集的介紹  並查集（Union/Find）從名字可以看出，主要涉及兩種基本操作:合併和查詢。這說明，初始時並查集中的元素是不相交的，經過一系列的基本操作(Union)，最終合併成一個大的集合。 而在某次合併之後，有一種合理的需求：某兩個元素是否已經處在同一個集合中了？因此就需要Find操作。 並

2019.9.17 初級資料結構——並查集及其應用

一、並查集基礎 （一）引入 我們先來看一個問題。 某學校有N個學生，形成M個俱樂部。每個俱樂部裡的學生有著一定相似的興趣愛好，形成一個朋友圈。一個學生可以同時屬於若干個不同的俱樂部。根據“我的朋友的朋友也是我的朋友”這個推論可以得出，如果A和B是朋友，且B和C是朋友，則A和C也是

數據結構 並查集

一個 efault mar left pts turn 一個數 baseline 數組 並查集是一種數據結構，字面意思上來說，就是一個支持合並和查詢的集合。 並查集 並查集的建立 1 void init() 2 { 3 for (int i = 1; i <

NOI2018歸程（Kruskal重構樹）(以及騙分數據結構並查集）

沒有 這一 目標 div 相對 之前 大寫字母 top color 題目描述 本題的故事發生在魔力之都，在這裏我們將為你介紹一些必要的設定。 魔力之都可以抽象成一個 n 個節點、m 條邊的無向連通圖（節點的編號從 1 至 n）。 我們依次用 l,a 描述一條邊的長度、海拔

數據結構——並查集

技術 bool 數組 用戶 span pen main 就是 set 並查集，是我目前為止見過的，實現起來最淳樸的數據結構，但是功能也很強大。 並查集核心由三個數組和兩個函數構成。 數組pre[ ]記錄了每個點的前導點是什麽，數組data[ ]記錄數據，數組size[

noip提高組資料結構模板[並查集,st表,樹狀陣列,線段樹]

/*資料結構*/ //並查集 for(int i=1;i<=n;i++) fa[i]=i;*** int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);} //st表 for(int i=2;i<=n;i++) Log[i]=Lo

資料結構學習筆記------並查集（附cf例題）

並查集是將原始的資料集S看成一個森林，每棵樹代表一個集合。初始時，每個資料看成一顆只有根節點的樹，根據具體要求，將若干樹合併起來組成若干個含有節點較多的樹，每棵樹就是一個集合。此資料結構可以方便的對資料集S進行：（1）查詢其屬於哪個集合（2）將一個集合合併到另一個集合的操作。要注意的是，

[學習筆記]可持久化資料結構 可持久化並查集

可持久化：支援查詢歷史版本和在歷史版本上修改   可持久化陣列 主席樹做即可。 【模板】可持久化陣列（可持久化線段樹/平衡樹）   可持久化並查集 可持久化並查集 主席樹做即可。 要按秩合併。（路徑壓縮每次建logn條鏈，會卡爆空間MLE） 主席樹節點，維護father

資料結構09—— 並查集（Union-Find）

一、關於並查集 並查集（Union-Find）是一種樹型的資料結構，常用於處理一些不相交集合（Disjoint Sets）的合併及查詢問題。並查集（Union-Find）從名字可以看出，主要它涉及兩種基本操作:合併和查詢。這說明，初始時並查集中的元素是不相交的，經過一系列的基本操作(Union)

資料結構實現 9.1：並查集_陣列結構實現（C++版）

資料結構實現 9.1：並查集_陣列結構實現（C++版） 1. 概念及基本框架 2. 基本操作程式實現 2.1 聯合操作 2.2 查詢操作 2.3 其他操作 3. 演算法複雜度分析 3.1 聯合操作

資料結構實現 9.2：並查集_樹思想實現（C++版）

資料結構實現 9.2：並查集_樹思想實現（C++版） 1. 概念及基本框架 2. 基本操作程式實現 2.1 聯合操作 2.2 查詢操作 2.3 其他操作 3. 演算法複雜度分析 3.1 聯合操作

（Java資料結構和演算法）最小生成樹---Kruskal演算法（並查集）

該文章利用prime演算法求得連通圖的最小生成樹對應的邊權最小和，prime演算法是從頂點的角度思考和解決問題。本文介紹的Kruskal演算法將從邊的角度考慮並解決問題，利用了並查集方便地解決了最小生成樹的問題。 本文參考博文 //並查集 class UnionSameSet{

基礎演算法與資料結構（三）普通並查集

簡介 在平時的計算中，常常會遇到集合劃分的問題，例如一個集合S={a1,a2,a3,a4}，按照一定規則我們可以劃分為S1={a1,a2}，S2={a3}，s3={a4}。但是在劃分好集合後，又該如何快速確認任意兩個元素之間的關係呢。由此引出並查集。 並查集簡介 並查集最關鍵的表現就是一個集合中的每