solves #323: Number of Connected Components in an Undirected Graph in java

Author: anishLearnsToCode

Diff for: README.md

@@ -270,7 +270,7 @@
 | 319  | [Bulb Switcher](https://leetcode.com/problems/bulb-switcher)                                                                                                           |                                                                                                                                                                                                                                  |                                                                                                                                   |
 | 320  | 🔒 [Generalized Abbreviation](https://leetcode.com/problems/generalized-abbreviation)                                                                                  |                                                                                                                                                                                                                                  |                                                                                                                                   |
 | 322  | [Coin Change](https://leetcode.com/problems/coin-change)                                                                                                               |                                                                                                                                                                                                                                  |                                                                                                                                   |
-| 323  | 🔒 [Number of Connected Components in Undirected Graph](https://leetcode.com/problems/number-of-connected-components-in-an-undirected-graph)                           |                                                                                                                                                                                                                                  |                                                                                                                                   |
+| 323  | 🔒 [Number of Connected Components in Undirected Graph](https://leetcode.com/problems/number-of-connected-components-in-an-undirected-graph)                           |                                                                       [![Java](assets/java.png)](src/NumberOfConnectedComponentsInAnUndirectedGraph.java)                                                                        |                                                                                                                                   |
 | 324  | [Wiggle Sort II](https://leetcode.com/problems/wiggle-sort-ii)                                                                                                         |                                                                                                                                                                                                                                  |                                                                                                                                   |
 | 325  | 🔒 [Maximum Size Subarray Sum Equals K](https://leetcode.com/problems/maximum-size-subarray-sum-equals-k)                                                              |                                                                                                                                                                                                                                  |                                                                                                                                   |
 | 326  | [Power of Three](https://leetcode.com/problems/power-of-three)                                                                                                         |                                                            [![Java](assets/java.png)](src/PowerOfThree.java) [![Python](assets/python.png)](python/power_of_three.py)                                                            |                                                                                                                                   |

Diff for: src/NumberOfConnectedComponentsInAnUndirectedGraph.java

@@ -0,0 +1,55 @@
+// https://leetcode.com/problems/number-of-connected-components-in-an-undirected-graph
+// T: O(V + E * alpha(V)) alpha = inverse ackerman function
+// S: O(V)
+
+public class NumberOfConnectedComponentsInAnUndirectedGraph {
+    private static final class DisjointSet {
+        private final int[] root, rank;
+
+        public DisjointSet(int size) {
+            root = new int[size];
+            rank = new int[size];
+            for (int i = 0 ; i < size ; i++) {
+                root[i] = i;
+                rank[i] = 1;
+            }
+        }
+
+        public int find(int num) {
+            if (num == root[num]) {
+                return num;
+            }
+            return root[num] = find(root[num]);
+        }
+
+        public boolean areConnected(int x, int y) {
+            return find(x) == find(y);
+        }
+
+        public void union(int x, int y) {
+            final int rootX = find(x), rootY = find(y);
+            if (rootX == rootY) {
+                return;
+            }
+            if (rank[rootX] < rank[rootY]) {
+                root[rootX] = rootY;
+            } else if (rank[rootX] > rank[rootY]) {
+                root[rootY] = rootX;
+            } else {
+                root[rootY] = rootX;
+                rank[rootX]++;
+            }
+        }
+    }
+
+    public int countComponents(int n, int[][] edges) {
+        final DisjointSet disjointSet = new DisjointSet(n);
+        for (int[] edge : edges) {
+            if (!disjointSet.areConnected(edge[0], edge[1])) {
+                disjointSet.union(edge[0], edge[1]);
+                n--;
+            }
+        }
+        return n;
+    }
+}