refactor 323

Author: fishercoder1534

paginated_contents/algorithms/1st_thousand/README.md

@@ -507,7 +507,7 @@
 | 326 | [Power of Three](https://leetcode.com/problems/power-of-three/)                                                                                                                               | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_326.java)                                                                  |                                                                               | Easy                             | Math                                                                 
 | 325 | [Maximum Size Subarray Sum Equals k](https://leetcode.com/problems/maximum-size-subarray-sum-equals-k/)                                                                                       | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_325.java)                                                                  |                                                                               | Medium                           | HashTable                                                            
 | 324 | [Wiggle Sort II](https://leetcode.com/problems/wiggle-sort-ii/)                                                                                                                               | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_324.java)                                                                  |                                                                               | Medium                           | Sort                                                                 
-| 323 | [Number of Connected Components in an Undirected Graph](https://leetcode.com/problems/number-of-connected-components-in-an-undirected-graph/)                                                 | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_323.java)                                                                  |                                                                               | Medium                           |
+| 323 | [Number of Connected Components in an Undirected Graph](https://leetcode.com/problems/number-of-connected-components-in-an-undirected-graph/)                                                 | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_323.java)                                                                  |                                                                               | Medium                           | BFS
 | 322 | [Coin Change](https://leetcode.com/problems/coin-change/)                                                                                                                                     | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_322.java)                                                                  |                                                                               | Medium                           | DP                                                                   
 | 321 | [Create Maximum Number](https://leetcode.com/problems/create-maximum-number/)                                                                                                                 | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_321.java)                                                                  |                                                                               | Hard                             
 | 320 | [Generalized Abbreviation](https://leetcode.com/problems/generalized-abbreviation/)                                                                                                           | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_320.java)                                                                  |                                                                               | Medium                           | Backtracking, Bit Manipulation                                       

src/main/java/com/fishercoder/solutions/firstthousand/_323.java

@@ -7,42 +7,35 @@
 
 public class _323 {
     public static class Solution1 {
-
+        /**
+         * Use BFS to iterate through all nodes and their connected neighbors
+         */
         public int countComponents(int n, int[][] edges) {
-            if (n <= 1) {
-                return n;
-            }
-
-            List<List<Integer>> adList = new ArrayList<>();
+            //build the adjacency list;
+            List<List<Integer>> adj = new ArrayList<>();
             for (int i = 0; i < n; i++) {
-                adList.add(new ArrayList<>());
+                adj.add(new ArrayList<>());
             }
-
             for (int[] edge : edges) {
-                adList.get(edge[0]).add(edge[1]);
-                adList.get(edge[1]).add(edge[0]);
-            }
-
-            for (List<Integer> list : adList) {
-                for (int i : list) {
-                    System.out.print(i + ", ");
-                }
-                System.out.println();
+                adj.get(edge[0]).add(edge[1]);
+                adj.get(edge[1]).add(edge[0]);
             }
 
             boolean[] visited = new boolean[n];
             int count = 0;
+
             for (int i = 0; i < n; i++) {
                 if (!visited[i]) {
                     count++;
-                    Queue<Integer> q = new LinkedList<>();
-                    q.offer(i);
-                    while (!q.isEmpty()) {
-                        int index = q.poll();
-                        visited[index] = true;
-                        for (int j : adList.get(index)) {
-                            if (!visited[j]) {
-                                q.offer(j);
+                    Queue<Integer> queue = new LinkedList<>();
+                    queue.offer(i);
+
+                    while (!queue.isEmpty()) {
+                        int currNode = queue.poll();
+                        visited[currNode] = true;
+                        for (int neighbor : adj.get(currNode)) {
+                            if (!visited[neighbor]) {
+                                queue.offer(neighbor);
                             }
                         }
                     }