144. Binary Tree Preorder Traversal

题目：

Given a binary tree, return the preorder traversal of its nodes' values.

For example:
Given binary tree

{1,#,2,3}

,

1
\
2
/
3

return

[1,2,3]

.

Note: Recursive solution is trivial, could you do it iteratively?

Hide Tags
Tree Stack

连接： http://leetcode.com/problems/binary-tree-preorder-traversal/

题解：

二叉树先序遍历， root -> left -> right。使用一个栈来维护已经访问过的节点。当root不为空时，当前节点入栈，输出节点值，继续向左子树遍历。当root为空，从栈中弹出节点，向右子树进行遍历。

Iterative:

Time Complexity - O(n)， Space Complexity - O(n)。

public class Solution {
public ArrayList<Integer> preorderTraversal(TreeNode root) {
ArrayList<Integer> result = new ArrayList<Integer>();
if(root == null)
return result;
Stack<TreeNode> stack = new Stack<TreeNode>();

while(root != null || !stack.isEmpty()){
if(root != null){
stack.push(root);
result.add(root.val);
root = root.left;
} else {
root = stack.pop();
root = root.right;
}
}

return result;
}
}

Recursive:

Time Complexity - O(n)， Space Complexity - O(n)。

public class Solution {
public ArrayList<Integer> preorderTraversal(TreeNode root) {
ArrayList<Integer> result = new ArrayList<Integer>();
if(root == null)
return result;
helper(result, root);
return result;
}

private void helper(ArrayList<Integer> result, TreeNode root){
if(root == null)
return;
result.add(root.val);
helper(result, root.left);
helper(result, root.right);
}
}

Update:

/**
* Definition for a binary tree node.
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
if(root == null)
return res;
Stack<TreeNode> stack = new Stack<>();
stack.push(root);

while(!stack.isEmpty()) {
root = stack.pop();
if(root != null) {
res.add(root.val);
if(root.right != null)
stack.push(root.right);
if(root.left != null)
stack.push(root.left);
}
}

return res;
}
}

Morris-Travel: 待定。

二刷:

Java:

/**
* Definition for a binary tree node.
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
if (root == null) {
return res;
}
Stack<TreeNode> stack = new Stack<>();
while (root != null || !stack.isEmpty()) {
if (root != null) {
res.add(root.val);
stack.push(root.right);
root = root.left;
} else {
root = stack.pop();
}
}
return res;
}
}

三刷:

Java:

/**
* Definition for a binary tree node.
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
Stack<TreeNode> stack = new Stack<>();

while (!stack.isEmpty() || root != null) {
if (root != null) {
res.add(root.val);
stack.push(root.right);
root = root.left;
} else {
root = stack.pop();
}
}
return res;
}
}

Recursive:

/**
* Definition for a binary tree node.
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
preorderTraversal(res, root);
return res;
}

private void preorderTraversal(List<Integer> res, TreeNode root) {
if (root == null) return;
res.add(root.val);
preorderTraversal(res, root.left);
preorderTraversal(res, root.right);
}
}

Reference：
https://leetcode.com/discuss/9734/accepted-code-explaination-with-algo https://leetcode.com/discuss/5331/whats-the-simplest-and-cleanest-answer https://leetcode.com/discuss/23326/very-simple-iterative-python-solution https://leetcode.com/discuss/19798/accepted-iterative-solution-in-java-using-stack https://leetcode.com/discuss/32904/3-different-solutions https://leetcode.com/discuss/49926/easy-read-java-solutions-for-both-iterative-recursive-300ms https://leetcode.com/discuss/46894/java-solution-both-recursion-and-iteration