#94 二叉树中序遍历，递归版本和栈迭代版本

Author: Isaaclot

main/test/tree/LC_94_InOrderTraversal.java

@@ -0,0 +1,58 @@
+package tree;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+/**
+ * @author alis
+ * @date 2019/10/26 12:32 AM
+ * @description
+ */
+public class LC_94_InOrderTraversal {
+
+    /**
+     * 利用栈迭代式中序遍历二叉树：左 根 右
+     * 利用栈先进后出的特性
+     * 先把根目录下的左结点，入栈，直至到最左结点(第一个输出的结点)
+     * 判断出栈输出条件：栈顶
+     * 如果已出栈结点存在右子结点，则右子结点入栈，并结束本次内循环，
+     * 将本右子结点的所有左子结点入栈，重复以上步骤进行迭代循环
+     */
+    public List<Integer> inOrderTraversal(TreeNode root) {
+        List<Integer> nums = new ArrayList<>();
+        if (null == root) return nums;
+        Stack<TreeNode> stack = new Stack<>();
+        stack.add(root);
+        while (!stack.isEmpty()) {
+            while (stack.peek().left != null) {
+                stack.push(stack.peek().left);
+            }
+            while (!stack.isEmpty()) {
+                TreeNode node = stack.pop();
+                nums.add(node.val);
+                if (node.right != null) {
+                    stack.push(node.right);
+                    break;
+                }
+            }
+        }
+        return nums;
+    }
+
+    /**
+     * 递归遍历二叉树，中序遍历：左 根 🈶右
+     */
+    public List<Integer> inOrderTraversalReverse(TreeNode root) {
+        List<Integer> nums = new ArrayList<>();
+        if (nums == root) return nums;
+        if (root.left != null) {
+            nums.addAll(inOrderTraversalReverse(root.left));
+        }
+        nums.add(root.val);
+        if (root.right != null) {
+            nums.addAll(inOrderTraversalReverse(root.right));
+        }
+        return nums;
+    }
+}

main/test/tree/LC_94_InOrderTraversalTest.java

@@ -0,0 +1,57 @@
+package tree;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+/**
+ * @author alis
+ * @date 2019/10/26 12:24 AM
+ * @description
+ */
+public class LC_94_InOrderTraversalTest {
+    private LC_94_InOrderTraversal inOrderTraversal = new LC_94_InOrderTraversal();
+
+    @Test
+    public void inOrderTraversalStackTest() {
+        TreeNode root = new TreeNode(1);
+        TreeNode root2 = new TreeNode(2);
+        root2.left = new TreeNode(3);
+        root.right = root2;
+        List<Integer> nums = inOrderTraversal.inOrderTraversal(root);
+        int[] result = new int[nums.size()];
+        for (int i = 0; i < nums.size(); i++) {
+            result[i] = nums.get(i);
+        }
+        Assert.assertArrayEquals(result, new int[]{1, 3, 2});
+    }
+
+    @Test
+    public void inOrderTraversalReverseTest() {
+        TreeNode root = new TreeNode(1);
+        TreeNode root2 = new TreeNode(2);
+        root2.left = new TreeNode(3);
+        root.right = root2;
+        List<Integer> nums = inOrderTraversal.inOrderTraversalReverse(root);
+        int[] result = new int[nums.size()];
+        for (int i = 0; i < nums.size(); i++) {
+            result[i] = nums.get(i);
+        }
+        Assert.assertArrayEquals(result, new int[]{1, 3, 2});
+    }
+
+}
+
+/**
+ * Definition for a binary tree node.
+ */
+class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+
+    TreeNode(int x) {
+        val = x;
+    }
+}