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

Author: Isaaclot

main/src/tree/LC_144_PreOrderTraversal.java

@@ -0,0 +1,58 @@
+package tree;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+/**
+ * @author alis
+ * @date 2019/10/27 12:55 AM
+ * @description
+ */
+public class LC_144_PreOrderTraversal {
+
+
+    /**
+     * 二叉树前序遍历：根 左 右
+     * 递归
+     */
+    public List<Integer> preOrderTraversalRecur(tree.TreeNode root) {
+        List<Integer> nums = new ArrayList<>();
+        // terminator
+        if (null == root) return nums;
+
+        // process
+        nums.add(root.val);
+
+        // drill down
+        if (root.left != null) nums.addAll(preOrderTraversalRecur(root.left));
+        if (root.right != null) nums.addAll(preOrderTraversalRecur(root.right));
+
+        // reverse states
+
+        return nums;
+    }
+
+    /**
+     * 栈迭代 前序遍历二叉树
+     * 核心思想：先将根结点入栈，在while循环中取出，如果子结点不为空，先入栈右结点，再入栈左结点，
+     * 继续while循环，输出根结点的值
+     */
+    public List<Integer> preOrderTraversalStack(TreeNode root) {
+        List<Integer> nums = new ArrayList<>();
+        if (null == root) return nums;
+        Stack<TreeNode> stack = new Stack<>();
+        stack.add(root);
+        while (!stack.isEmpty()) {
+            TreeNode node = stack.pop();
+            nums.add(node.val);
+            if (node.right != null) {
+                stack.push(node.right);
+            }
+            if (node.left != null) {
+                stack.push(node.left);
+            }
+        }
+        return nums;
+    }
+}

main/test/tree/LC_144_PreOrderTraversalTest.java

@@ -0,0 +1,45 @@
+package tree;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+/**
+ * @author alis
+ * @date 2019/10/27 12:53 AM
+ * @description
+ */
+public class LC_144_PreOrderTraversalTest {
+
+    private LC_144_PreOrderTraversal preOrderTraversal = new LC_144_PreOrderTraversal();
+
+    @Test
+    public void preOrderTraversalTest() {
+        TreeNode root = new TreeNode(1);
+        TreeNode node2 = new TreeNode(2);
+        TreeNode node3 = new TreeNode(3);
+        node2.left = node3;
+        root.right = node2;
+        List<Integer> expected = Arrays.asList(1, 2, 3);
+        List<Integer> res = preOrderTraversal.preOrderTraversalRecur(root);
+        assertThat(res, is(expected));
+    }
+
+    @Test
+    public void preOrderTraversalStackTest() {
+        TreeNode root = new TreeNode(1);
+        TreeNode node2 = new TreeNode(2);
+        TreeNode node3 = new TreeNode(3);
+        node2.left = node3;
+        root.right = node2;
+        List<Integer> expected = Arrays.asList(1, 2, 3);
+        List<Integer> res = preOrderTraversal.preOrderTraversalStack(root);
+        assertThat(res, is(expected));
+    }
+
+
+}