Initial Commit.

QuickFind.java

@@ -0,0 +1,33 @@
+public class QuickFind {
+    private int[] id;
+    public QuickFind(int N)
+    {
+        id = new int[N];
+        for (int i = 0; i < N; i++)
+            id[i] = i;
+    }
+
+    public boolean connected(int id1, int id2) {
+        return id[id1] == id[id2];
+    }
+
+    public void union(int id1, int id2) {
+        int id_1 = id[id1];
+        int id_2 = id[id2];
+        for (int i = 0; i < id.length; i++) {
+            if (id[i] == id_1) id[i] = id_2; 
+        }
+    }
+
+    public static void main(String[] args) {
+        QuickFind q = new QuickFind(10);
+        q.union(3, 8);
+        q.union(5, 2);
+        q.union(2, 3);
+        q.union(9, 1);
+        q.union(7, 4);
+        q.union(3, 9);
+        for (int i = 0; i < 10; i++) 
+            System.out.print(q.id[i] + " ");
+    }
+}

QuickUnion.java

@@ -0,0 +1,31 @@
+public class QuickUnion {
+    public int[] id;
+    public QuickUnion(int N)
+    {
+        id = new int[N];
+        for (int i = 0; i < N; i++)
+            id[i] = i;
+    }
+
+    public int root(int p) {
+        while (id[p] != p) p = id[p];
+        return p;
+    }
+
+    public boolean connected(int id1, int id2) {
+        return root(id1) == root(id2);
+    }
+
+    public void union(int p, int q) {
+        id[root(p)] = root(q);
+    }
+
+    public static void main(String[] args) {
+        int N = 10;
+        QuickUnion q = new QuickUnion(N);
+        q.union(1, 2);
+        q.union(2, 3);
+        for (int i = 0; i < N; i++) 
+            System.out.print(q.id[i] + " ");
+    }
+}

QuickUnionPathCompression.java

@@ -0,0 +1,42 @@
+public class QuickUnionPathCompression {
+    public int[] id;
+    private int[] sz;
+    public QuickUnionPathCompression(int N)
+    {
+        id = new int[N];
+        sz = new int[N];
+        for (int i = 0; i < N; i++) {
+            id[i] = i;
+            sz[i] = 1;
+        }
+    }
+
+    public int root(int p) {
+        int q = p;
+        while (id[p] != q) { q = id[p];} 
+        id[p] = q; // Path Compression, Planerize
+        sz[q] = 2; // Change the size after path compression
+        return q;
+    }
+
+    public boolean connected(int id1, int id2) {
+        return root(id1) == root(id2);
+    }
+
+    public void union(int p, int q) {
+        int i = root(p);
+        int j = root(q);
+        if (sz[i] < sz[j]) { id[i] = j; sz[j] += sz[i]; }
+        else               { id[j] = i; sz[i] += sz[j]; } 
+    }
+
+    public static void main(String[] args) {
+        int N = 10;
+        QuickUnionPathCompression q = new QuickUnionPathCompression(N);
+        q.union(1, 2);
+        q.union(2, 3);
+        for (int i = 0; i < N; i++) 
+            System.out.print(q.id[i] + " ");
+        System.out.println(q.connected(1, 3));
+    }
+}

QuickUnionWeighted.java

@@ -0,0 +1,45 @@
+public class QuickUnionWeighted {
+    public int[] id;
+    private int[] sz;
+    public QuickUnionWeighted(int N)
+    {
+        id = new int[N];
+        sz = new int[N];
+        for (int i = 0; i < N; i++) {
+            id[i] = i;
+            sz[i] = 1;
+        }
+    }
+
+    private int root(int p) {
+        while (id[p] != p) p = id[p];
+        return p;
+    }
+
+    public boolean connected(int id1, int id2) {
+        return root(id1) == root(id2);
+    }
+
+    public void union(int p, int q) {
+        int i = root(p);
+        int j = root(q);
+        if (sz[i] < sz[j]) { id[i] = j; sz[j] += sz[i]; }
+        else               { id[j] = i; sz[i] += sz[j]; } 
+    }
+
+    public static void main(String[] args) {
+        int N = 10;
+        QuickUnionWeighted q = new QuickUnionWeighted(N);
+        q.union(8, 1);
+        q.union(6, 3);
+        q.union(5, 0);
+        q.union(4, 7);
+        q.union(3, 8);
+        q.union(4, 9);
+        q.union(5, 4);
+        q.union(7, 6);
+        q.union(7, 2);
+        for (int i = 0; i < N; i++) 
+            System.out.print(q.id[i] + " ");
+    }
+}

Readme.md

@@ -0,0 +1 @@
+Implementation of Union-Find algorithm in java.