quick find

Author: msa-ali

data-structure-and-algorithms/algorithms/Union-Find/QuickFind.ts

@@ -0,0 +1,27 @@
+// Union - O(n)
+// Find - O(1)
+// Init - O(n)
+export class QuickFindUF {
+    private id: number[];
+    private size: number;
+
+    constructor(n: number) {
+        this.size = n;
+        this.id = new Array(n).fill(0).map((_, i) => i);
+    }
+
+    public connected(p: number, q: number): boolean {
+        return this.id[p] === this.id[q];
+    }
+
+    public union(p: number, q: number): void {
+        const newId = this.id[q];
+        const previousId = this.id[p];
+
+        for(let i = 0; i < this.size; i++) {
+            if (this.id[i] === previousId) {
+                this.id[i] = newId;
+            }
+        }
+    }
+}

data-structure-and-algorithms/algorithms/Union-Find/QuickUnion.ts

@@ -0,0 +1,33 @@
+// Union - O(n)
+// Find - O(1)
+// Init - O(n)
+export class QuickUnionUF {
+    private id: number[];
+    private size: number;
+
+    constructor(n: number) {
+        this.size = n;
+        this.id = new Array(n).fill(0).map((_, i) => i);
+    }
+
+    public connected(p: number, q: number): boolean {
+        return this.root(p) === this.root(q);
+    }
+
+    public union(p: number, q: number): void {
+        const newId = this.id[q];
+        const previousId = this.id[p];
+
+        for(let i = 0; i < this.size; i++) {
+            if (this.id[i] === previousId) {
+                this.id[i] = newId;
+            }
+        }
+    }
+
+    private root(node: number): number {
+        // chase parent pointers until reaches root
+        while(this.id[node] !== node) node = this.id[node];
+        return node;
+    }
+}

data-structure-and-algorithms/algorithms/Union-Find/QuickUnionPathCompression.ts

@@ -0,0 +1,36 @@
+// Union - O(n)
+// Find - O(1)
+// Init - O(n)
+export class QuickUnionUF {
+    private id: number[];
+    private size: number;
+
+    constructor(n: number) {
+        this.size = n;
+        this.id = new Array(n).fill(0).map((_, i) => i);
+    }
+
+    public connected(p: number, q: number): boolean {
+        return this.root(p) === this.root(q);
+    }
+
+    public union(p: number, q: number): void {
+        const newId = this.id[q];
+        const previousId = this.id[p];
+
+        for(let i = 0; i < this.size; i++) {
+            if (this.id[i] === previousId) {
+                this.id[i] = newId;
+            }
+        }
+    }
+
+    private root(node: number): number {
+        // chase parent pointers until reaches root
+        while(this.id[node] !== node) {
+            this.id[node] = this.id[this.id[node]]
+            node = this.id[node];
+        }
+        return node;
+    }
+}

data-structure-and-algorithms/algorithms/Union-Find/WeightedQuickUnion.ts

@@ -0,0 +1,41 @@
+// Running Time
+// Find - takes time proportional to depth of p and q - lg N
+// Union - takes constant time, given roots, lg N
+// Depth of any node is at most lg N where lg = base-2 logarithm
+export class QuickUnionUF {
+    private id: number[];
+    private size: number;
+    private nodeSize: number[];
+
+    constructor(n: number) {
+        this.size = n;
+        this.id = new Array(n).fill(0).map((_, i) => i);
+        this.nodeSize = new Array(n).fill(0).map(() => 1);
+
+    }
+
+    public connected(p: number, q: number): boolean {
+        return this.root(p) === this.root(q);
+    }
+
+    public union(p: number, q: number): void {
+        const i = this.id[q];
+        const j = this.id[p];
+
+        for (let i = 0; i < this.size; i++) {
+            if(this.nodeSize[i] < this.nodeSize[j]){
+                this.id[i] = j;
+                this.nodeSize[j] += this.nodeSize[i];
+            } else {
+                this.id[j] = i;
+                this.nodeSize[i] += this.nodeSize[j];
+            }
+        }
+    }
+
+    private root(node: number): number {
+        // chase parent pointers until reaches root
+        while (this.id[node] !== node) node = this.id[node];
+        return node;
+    }
+}

data-structure-and-algorithms/algorithms/Union-Find/readme.md

@@ -0,0 +1,36 @@
+# Union-Find
+
+## Dynamic Connectivity
+
+Given a set of n objects:
+
+- Union command - connect two objects
+- Find / connected query - is there a path connecting two nodes?
+
+## Quick-Find (eager approach)
+
+- Integer array id[] of size N
+- Interpretation: p and q are connect if they have the same id.
+
+## Quick Union
+
+- Integer array id[] of size N
+- Interpretation:id[i] is parent of i.
+- Root of i is id[id[id[...id[i]...]]] ( keep going untill it doesnt change ) - algorithm ensures no cycle.
+- Find - Check if p and q have same root.
+- Union - To merge components containing p and q, set the id of p's root to the id of q's root.
+
+## Quick Union Improvement - Weighing Quick-Union
+
+- Modify quick-union to avoid tall trees.
+- keep track of size of each tree.
+- Balance by linking root of smaller tree to root of larger tree.
+
+## Quic Union Improvement 2 - Path Compression
+
+- Just after computing the root of p, set the id of each examined node to point to that root.
+
+## Weighted Quick-Union with path compression
+
+- Starting from an empty data structure, any sequence of M union-find ops on N objects  makes =<  c(N + Mlog*N) array access.
+- Analysis can be improved to N + M @a (M,N).