Add disjoint set

Author: Ren0503

src/data-structures/disjoint-set/DisjointSet.js

@@ -0,0 +1,97 @@
+import DisjointSetItem from './DisjointSetItem';
+
+export default class DisjointSet {
+    /**
+     * @param {function(value: *)} [keyCallback]
+     */
+    constructor(keyCallback) {
+        this.keyCallback = keyCallback;
+        this.items = {};
+    }
+
+    /**
+     * @param {*} itemValue
+     * @return {DisjointSet}
+     */
+    makeSet(itemValue) {
+        const disjointSetItem = new DisjointSetItem(itemValue, this.keyCallback);
+
+        if (!this.items[disjointSetItem.getKey()]) {
+            // Thêm chỉ số mới trong trường hợp nó chưa được biểu diễn.
+            this.items[disjointSetItem.getKey()] = disjointSetItem;
+        }
+
+        return this;
+    }
+
+    /**
+     * Tìm nút đại diện tập hợp.
+     *
+     * @param {*} itemValue
+     * @return {(string|null)}
+     */
+    find(itemValue) {
+        const templateDisjointItem = new DisjointSetItem(itemValue, this.keyCallback);
+
+        // Tự tìm mục;
+        const requiredDisjointItem = this.items[templateDisjointItem.getKey()];
+
+        if (!requiredDisjointItem) {
+            return null;
+        }
+
+        return requiredDisjointItem.getRoot().getKey();
+    }
+
+    /**
+     * Hợp theo cấp bậc.
+     *
+     * @param {*} valueA
+     * @param {*} valueB
+     * @return {DisjointSet}
+     */
+    union(valueA, valueB) {
+        const rootKeyA = this.find(valueA);
+        const rootKeyB = this.find(valueB);
+
+        if (rootKeyA === null || rootKeyB === null) {
+            throw new Error('One or two values are not in sets');
+        }
+
+        if (rootKeyA === rootKeyB) {
+            // Trong trường hợp nếu cả hai phần tử nằm trong cùng một tập hợp thì chỉ cần trả về khóa của nó.
+            return this;
+        }
+
+        const rootA = this.items[rootKeyA];
+        const rootB = this.items[rootKeyB];
+
+        if (rootA.getRank() < rootB.getRank()) {
+            // Nếu cây của rootB lớn hơn thì đặt rootB là gốc mới.
+            rootB.addChild(rootA);
+
+            return this;
+        }
+
+        // Nếu cây của rootA lớn hơn thì đặt rootA là gốc mới.
+        rootA.addChild(rootB);
+
+        return this;
+    }
+
+    /**
+     * @param {*} valueA
+     * @param {*} valueB
+     * @return {boolean}
+     */
+    inSameSet(valueA, valueB) {
+        const rootKeyA = this.find(valueA);
+        const rootKeyB = this.find(valueB);
+
+        if (rootKeyA === null || rootKeyB === null) {
+            throw new Error('One or two values are not in sets');
+        }
+
+        return rootKeyA === rootKeyB;
+    }
+}

src/data-structures/disjoint-set/DisjointSetItem.js

@@ -0,0 +1,95 @@
+export default class DisjointSetItem {
+    /**
+     * @param {*} value
+     * @param {function(value: *)} [keyCallback]
+     */
+    constructor(value, keyCallback) {
+        this.value = value;
+        this.keyCallback = keyCallback;
+        /** @var {DisjointSetItem} this.parent */
+        this.parent = null;
+        this.children = {};
+    }
+
+    /**
+     * @return {*}
+     */
+    getKey() {
+        // Cho phép người dùng định nghĩa khoá.
+        if (this.keyCallback) {
+            return this.keyCallback(this.value);
+        }
+
+        // Nếu không thì sử dụng khoá mặc định.
+        return this.value;
+    }
+
+    /**
+     * @return {DisjointSetItem}
+     */
+    getRoot() {
+        return this.isRoot() ? this : this.parent.getRoot();
+    }
+
+    /**
+     * @return {boolean}
+     */
+    isRoot() {
+        return this.parent === null;
+    }
+
+    /**
+     * Xếp hạng cơ bản dựa trên số lượng của các nhóm.
+     * @return {number}
+     */
+    getRank() {
+        if (this.getChildren().length === 0) {
+            return 0;
+        }
+
+        let rank = 0;
+
+        /** @var {DisjointSetItem} child */
+        this.getChildren().forEach((child) => {
+            // Đếm số con của nó.
+            rank += 1;
+
+            // Đồng thời thêm tất cả con vào con hiện tại.
+            rank += child.getRank();
+        });
+
+        return rank;
+    }
+
+    /**
+     * @return {DisjointSetItem[]}
+     */
+    getChildren() {
+        return Object.values(this.children);
+    }
+
+    /**
+     * @param {DisjointSetItem} parentItem
+     * @param {boolean} forceSettingParentChild
+     * @return {DisjointSetItem}
+     */
+    setParent(parentItem, forceSettingParentChild = true) {
+        this.parent = parentItem;
+        if (forceSettingParentChild) {
+            parentItem.addChild(this);
+        }
+
+        return this;
+    }
+
+    /**
+     * @param {DisjointSetItem} childItem
+     * @return {DisjointSetItem}
+     */
+    addChild(childItem) {
+        this.children[childItem.getKey()] = childItem;
+        childItem.setParent(this, false);
+
+        return this;
+    }
+}

src/data-structures/disjoint-set/README.md

@@ -0,0 +1,18 @@
+# Tập hợp không giao nhau
+
+Cấu trúc dữ liệu **tập hợp không giao nhau** hay tập hợp rời rạc là một cấu trúc dữ liệu để lưu trữ một tập hợp các phần tử được phân chia thành nhiều tập hợp con không giao nhau.
+
+Nó cung cấp các thao tác với thời gian gần như không đổi (được giới hạn bởi hàm ngược Ackermann) để *thêm các tập hợp mới*, *hợp nhất các tập hợp hiện có* và *xác định xem các phần tử có trong cùng một tập hợp hay không*. Ngoài ra còn nhiều công dụng khác (xem phần Ứng dụng), các tập hợp rời rạc đóng một vai trò quan trọng trong thuật toán Kruskal để tìm cây bao trùm nhỏ nhất của một đồ thị.
+
+![disjoint set](https://upload.wikimedia.org/wikipedia/commons/6/67/Dsu_disjoint_sets_init.svg)
+
+Thao tác *Tạo-Tập* tạo ra 8 phần tử.
+
+![disjoint set](https://upload.wikimedia.org/wikipedia/commons/a/ac/Dsu_disjoint_sets_final.svg)
+
+Sau một số thao tác *Hợp*, một số tập hợp đã được nhóm lại với nhau.
+
+## Liên kết
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Disjoint-set_data_structure)
+- [By Abdul Bari on YouTube](https://www.youtube.com/watch?v=wU6udHRIkcc&index=14&t=0s&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)