add 897

Author: fishercoder1534

README.md

@@ -39,6 +39,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |922|[Sort Array By Parity II](https://leetcode.com/problems/sort-array-by-parity-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_922.java) | O(n) | O(1) | |Easy|
 |917|[Reverse Only Letters](https://leetcode.com/problems/reverse-only-letters/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_917.java) | O(n) | O(n) | |Easy|
 |900|[Sort Array By Parity](https://leetcode.com/problems/sort-array-by-parity/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_900.java) | O(n) | O(1) | |Easy|
+|897|[Increasing Order Search Tree](https://leetcode.com/problems/increasing-order-search-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_897.java) | O(n) | O(n) | |Easy| DFS, recursion
 |896|[Monotonic Array](https://leetcode.com/problems/monotonic-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_896.java) | O(n) | O(1) | |Easy|
 |884|[Uncommon Words from Two Sentences](https://leetcode.com/problems/uncommon-words-from-two-sentences/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_884.java) | O(n) | O(k) | |Easy|
 |876|[Middle of the Linked List](https://leetcode.com/problems/middle-of-the-linked-list/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_876.java) | O(n) | O(1) | |Easy|

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

@@ -0,0 +1,82 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 897. Increasing Order Search Tree
+ *
+ * Given a tree, rearrange the tree in in-order so that the leftmost node in the tree is now the root of the tree, and every node has no left child and only 1 right child.
+ *
+ * Example 1:
+ * Input: [5,3,6,2,4,null,8,1,null,null,null,7,9]
+ *
+ *        5
+ *       / \
+ *     3    6
+ *    / \    \
+ *   2   4    8
+ *  /        / \
+ * 1        7   9
+ *
+ * Output: [1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]
+ *
+ *  1
+ *   \
+ *    2
+ *     \
+ *      3
+ *       \
+ *        4
+ *         \
+ *          5
+ *           \
+ *            6
+ *             \
+ *              7
+ *               \
+ *                8
+ *                 \
+ *                  9
+ * Note:
+ *
+ * The number of nodes in the given tree will be between 1 and 100.
+ * Each node will have a unique integer value from 0 to 1000.
+ *
+ */
+public class _897 {
+  public static class Solution1 {
+    public TreeNode increasingBST(TreeNode root) {
+      List<Integer> inorderList = new ArrayList<>();
+      inorderTraversal(root, inorderList);
+      return constructTree(inorderList);
+    }
+
+    private TreeNode constructTree(List<Integer> inorderList) {
+      if (inorderList.isEmpty() || inorderList.size() == 0) {
+        return null;
+      }
+      TreeNode root = new TreeNode(inorderList.get(0));
+      TreeNode tmp = root;
+      for (int i = 1; i < inorderList.size(); i++) {
+        tmp.right = new TreeNode(inorderList.get(i));
+        tmp = tmp.right;
+      }
+      return root;
+    }
+
+    private void inorderTraversal(TreeNode root, List<Integer> inorderList) {
+      if (root == null) {
+        return;
+      }
+      if (root.left != null) {
+        inorderTraversal(root.left, inorderList);
+      }
+      inorderList.add(root.val);
+      if (root.right != null) {
+        inorderTraversal(root.right, inorderList);
+      }
+    }
+  }
+}

src/test/java/com/fishercoder/_897Test.java

@@ -0,0 +1,28 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
+import com.fishercoder.solutions._897;
+import java.util.Arrays;
+import org.junit.Before;
+import org.junit.Test;
+
+public class _897Test {
+  private static _897.Solution1 solution1;
+  private static TreeNode root;
+  private static TreeNode actual;
+
+  @Before
+  public void setup() {
+    solution1 = new _897.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    root = TreeUtils.constructBinaryTree(
+        Arrays.asList(5, 3, 6, 2, 4, null, 8, 1, null, null, null, 7, 9));
+    TreeUtils.printBinaryTree(root);
+    actual = solution1.increasingBST(root);
+    TreeUtils.printBinaryTree(actual);
+  }
+}