refactor 99

fishercoder1534 · fishercoder1534 · commit 4500bd80168a · 2018-03-08T07:19:02.000-08:00
diff --git a/src/main/java/com/fishercoder/solutions/_99.java b/src/main/java/com/fishercoder/solutions/_99.java
@@ -1,49 +1,55 @@
 package com.fishercoder.solutions;
 
 import com.fishercoder.common.classes.TreeNode;
-/**Two elements of a binary search tree (BST) are swapped by mistake.
-
- Recover the tree without changing its structure.
+/**
+ * 99. Recover Binary Search Tree
+ *
+ * Two elements of a binary search tree (BST) are swapped by mistake.
+ * Recover the tree without changing its structure.
 
  Note:
- A solution using O(n) space is pretty straight forward. Could you devise a constant space solution?*/
+ A solution using O(n) space is pretty straight forward. Could you devise a constant space solution?
+ */
+
 public class _99 {
-	TreeNode firstElement = null;
-	TreeNode secondElement = null;
+  public static class Solution1 {
+    TreeNode firstElement = null;
+    TreeNode secondElement = null;
 
-	TreeNode prevElement = new TreeNode(Integer.MIN_VALUE);
+    TreeNode prevElement = new TreeNode(Integer.MIN_VALUE);
 
-	public void recoverTree(TreeNode root) {
-		traverseTree(root);
+    public void recoverTree(TreeNode root) {
+      traverseTree(root);
 
-		//swap the two elements
-		int temp = firstElement.val;
-		firstElement.val = secondElement.val;
-		secondElement.val = temp;
-	}
+      //swap the two elements
+      int temp = firstElement.val;
+      firstElement.val = secondElement.val;
+      secondElement.val = temp;
+    }
 
-	private void traverseTree(TreeNode root) {
-		if (root == null) {
-			return;
-		}
+    private void traverseTree(TreeNode root) {
+      if (root == null) {
+        return;
+      }
 
-		traverseTree(root.left);
+      traverseTree(root.left);
 
-		//prevElement means the one previous to the current root, refer to in-order traversal, previous element must be smaller than the current root
-		//if it's bigger, then we find the first element, thus we store it in the variable called firstElement
-		if (firstElement == null && prevElement.val >= root.val) {
-			firstElement = prevElement;
-		}
+      //prevElement means the one previous to the current root, refer to in-order traversal, previous element must be smaller than the current root
+      //if it's bigger, then we find the first element, thus we store it in the variable called firstElement
+      if (firstElement == null && prevElement.val >= root.val) {
+        firstElement = prevElement;
+      }
 
-		if (firstElement != null && prevElement.val >= root.val) {
-			secondElement = root;
-		}
+      if (firstElement != null && prevElement.val >= root.val) {
+        secondElement = root;
+      }
 
-		//this is the last step in the "do some business logic", so we'll always to have update the previous node to be the current root before it traverses the right subtree
-		//since the current root will be the new previous node for the right subtree.
-		prevElement = root;
+      //this is the last step in the "do some business logic", so we'll always to have update the previous node to be the current root before it traverses the right subtree
+      //since the current root will be the new previous node for the right subtree.
+      prevElement = root;
 
-		traverseTree(root.right);
-	}
+      traverseTree(root.right);
+    }
 
-}
+  }
+}
