refactor 133

Author: fishercoder1534

src/main/java/com/fishercoder/solutions/_133.java

@@ -1,37 +1,56 @@
 package com.fishercoder.solutions;
 
-import com.fishercoder.common.classes.UndirectedGraphNode;
-
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.LinkedList;
+import java.util.List;
 import java.util.Map;
 import java.util.Queue;
 
 public class _133 {
 
     public static class Solution1 {
-        public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
+        public Node cloneGraph(Node node) {
             if (node == null) {
                 return node;
             }
 
-            Map<Integer, UndirectedGraphNode> map = new HashMap();
-            Queue<UndirectedGraphNode> queue = new LinkedList();
-            UndirectedGraphNode root = new UndirectedGraphNode(node.val);
+            Map<Integer, Node> map = new HashMap();
+            Queue<Node> queue = new LinkedList();
+            Node root = new Node(node.val);
             map.put(root.val, root);
-            queue.offer(node);
             //remember to offer the original input node into the queue which contains all the information
+            queue.offer(node);
             while (!queue.isEmpty()) {
-                UndirectedGraphNode curr = queue.poll();
-                for (UndirectedGraphNode eachNode : curr.neighbors) {
+                Node curr = queue.poll();
+                for (Node eachNode : curr.neighbors) {
                     if (!map.containsKey(eachNode.val)) {
-                        map.put(eachNode.val, new UndirectedGraphNode(eachNode.val));
+                        map.put(eachNode.val, new Node(eachNode.val));
                         queue.offer(eachNode);
                     }
                     map.get(curr.val).neighbors.add(map.get(eachNode.val));
                 }
             }
             return root;
         }
+
+        class Node {
+            public int val;
+            public List<Node> neighbors;
+
+            public Node() {
+                this.neighbors = new ArrayList<>();
+            }
+
+            public Node(int val) {
+                this.val = val;
+                this.neighbors = new ArrayList<>();
+            }
+
+            public Node(int val, List<Node> neighbors) {
+                this.val = val;
+                this.neighbors = neighbors;
+            }
+        }
     }
 }

src/test/java/com/fishercoder/_133Test.java

@@ -1,5 +1,6 @@
 package com.fishercoder;
 
+import com.fishercoder.common.classes.Node;
 import com.fishercoder.common.classes.UndirectedGraphNode;
 import com.fishercoder.solutions._133;
 import org.junit.Before;
@@ -9,32 +10,32 @@
 import static junit.framework.Assert.assertEquals;
 
 public class _133Test {
-  private static _133.Solution1 solution1;
-  private static UndirectedGraphNode expected;
-  private static UndirectedGraphNode actual;
+    private static _133.Solution1 solution1;
+    private static Node expected;
+    private static Node actual;
 
-  @BeforeClass
-  public static void setup() {
-    solution1 = new _133.Solution1();
-  }
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _133.Solution1();
+    }
 
-  @Before
-  public void setupForEachTest() {
-    expected = null;
-    actual = null;
-  }
+    @Before
+    public void setupForEachTest() {
+        expected = null;
+        actual = null;
+    }
 
-  @Test
-  public void test1() {
-    UndirectedGraphNode node0 = new UndirectedGraphNode(0);
-    UndirectedGraphNode node1 = new UndirectedGraphNode(1);
-    UndirectedGraphNode node2 = new UndirectedGraphNode(2);
-    node0.neighbors.add(node1);
-    node0.neighbors.add(node2);
-    node1.neighbors.add(node2);
+    @Test
+    public void test1() {
+        Node node0 = new Node(0);
+        Node node1 = new Node(1);
+        Node node2 = new Node(2);
+        node0.children.add(node1);
+        node0.children.add(node2);
+        node1.children.add(node2);
 
-    expected = node0;
-    actual = solution1.cloneGraph(expected);
-    assertEquals(expected, actual);
-  }
+        expected = node0;
+        actual = solution1.cloneGraph(expected);
+        assertEquals(expected, actual);
+    }
 }