refactor 450

fishercoder1534 · fishercoder1534 · commit b90c66e2fd90 · 2019-04-12T08:23:02.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_450.java b/src/main/java/com/fishercoder/solutions/_450.java
@@ -44,42 +44,46 @@
    4   7
  */
 public class _450 {
-
-    /**credit: https://discuss.leetcode.com/topic/65792/recursive-easy-to-understand-java-solution
-     * Steps:
-     1. Recursively find the node that has the same value as the key, while setting the left/right nodes equal to the returned subtree
-     2. Once the node is found, have to handle the below 4 cases
-        a. node doesn't have left or right - return null
-        b. node only has left subtree- return the left subtree
-        c. node only has right subtree- return the right subtree
-        d. node has both left and right - find the minimum value in the right subtree, set that value to the currently found node, then recursively delete the minimum value in the right subtree*/
-    public TreeNode deleteNode(TreeNode root, int key) {
-        if (root == null) {
-            return root;
-        }
-        if (root.val > key) {
-            root.left = deleteNode(root.left, key);
-        } else if (root.val < key) {
-            root.right = deleteNode(root.right, key);
-        } else {
-            if (root.left == null) {
-                return root.right;
-            } else if (root.right == null) {
-                return root.left;
+    public static class Solution1 {
+
+        /**
+         * credit: https://discuss.leetcode.com/topic/65792/recursive-easy-to-understand-java-solution
+         * Steps:
+         * 1. Recursively find the node that has the same value as the key, while setting the left/right nodes equal to the returned subtree
+         * 2. Once the node is found, have to handle the below 4 cases
+         * a. node doesn't have left or right - return null
+         * b. node only has left subtree- return the left subtree
+         * c. node only has right subtree- return the right subtree
+         * d. node has both left and right - find the minimum value in the right subtree, set that value to the currently found node, then recursively delete the minimum value in the right subtree
+         */
+        public TreeNode deleteNode(TreeNode root, int key) {
+            if (root == null) {
+                return root;
             }
-
-            TreeNode minNode = getMin(root.right);
-            root.val = minNode.val;
-            root.right = deleteNode(root.right, root.val);
+            if (root.val > key) {
+                root.left = deleteNode(root.left, key);
+            } else if (root.val < key) {
+                root.right = deleteNode(root.right, key);
+            } else {
+                if (root.left == null) {
+                    return root.right;
+                } else if (root.right == null) {
+                    return root.left;
+                }
+
+                TreeNode minNode = getMin(root.right);
+                root.val = minNode.val;
+                root.right = deleteNode(root.right, root.val);
+            }
+            return root;
         }
-        return root;
-    }
 
-    private TreeNode getMin(TreeNode node) {
-        while (node.left != null) {
-            node = node.left;
+        private TreeNode getMin(TreeNode node) {
+            while (node.left != null) {
+                node = node.left;
+            }
+            return node;
         }
-        return node;
     }
 
 }
diff --git a/src/test/java/com/fishercoder/_450Test.java b/src/test/java/com/fishercoder/_450Test.java
@@ -7,18 +7,14 @@
 
 import static org.junit.Assert.assertEquals;
 
-/**
- * Created by stevesun on 5/29/17.
- */
 public class _450Test {
-    private static _450 test;
+    private static _450.Solution1 solution1;
     private static TreeNode expected;
-    private static TreeNode actual;
     private static TreeNode root;
 
     @BeforeClass
     public static void setup() {
-        test = new _450();
+        solution1 = new _450.Solution1();
     }
 
     @Test
@@ -36,6 +32,6 @@ public void test1() {
         expected.left.left = new TreeNode(2);
         expected.right.right = new TreeNode(7);
 
-        assertEquals(expected, test.deleteNode(root, 3));
+        assertEquals(expected, solution1.deleteNode(root, 3));
     }
 }
