Binary Tree Preorder Traversal & Binary Tree Inorder Traversal & Binary Tree Postorder Traversal

这一篇补充下leetcode上的二叉树的三种遍历的迭代实现。基本上是参照往上的来的。写的比较清晰 链接：https://segmentfault.com/a/1190000003532763 

自己都实现了一遍。这种基础的算法还是要牢固一些。

第一题前序遍历：

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]

.
思路是使用一个栈，先访问父节点，如果右孩子存在，把右孩子压入栈，如果左孩子存在，那么左孩子压入栈。因为栈是先进后出，所以先右孩子再左孩子。
代码：

public List<Integer> preorderTraversal(TreeNode root) {
Stack<TreeNode> stack = new Stack<>();
List<Integer> result = new ArrayList<>();

if(root != null) stack.push(root);
while(!stack.isEmpty()){
TreeNode node = stack.pop();
result.add(node.val);
if(node.right!= null) stack.push(node.right);//先进后出
if(node.left!= null) stack.push(node.left);
}
return result;
}

中序遍历：

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

For example:

Given binary tree 

[1,null,2,3]

,

1
\
2
/
3

这道题的思路是首先一路沿着左边依次压入栈。弹栈的时候，如果当前这个点存在右孩子，那么把这个点的右孩子以及右孩子的左边的节点都加入到栈。
代码：

public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> res = new LinkedList<Integer>();
Stack<TreeNode> stack = new Stack<>();

if(root != null){
pushAllLeft(stack, root);
}

while(!stack.isEmpty()){
TreeNode node = stack.pop();
res.add(node.val);
if(node.right != null){
pushAllLeft(stack, node.right);
}
}
return res;
}

private void pushAllLeft(Stack<TreeNode> s, TreeNode root){
s.push(root);
while(root.left != null){
root = root.left;
s.push(root);
}
}

后序遍历

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

For example:

Given binary tree 

{1,#,2,3}

,

1
\
2
/
3

return 

[3,2,1]

.
基本上有两种方式：
1. 因为在迭代实现的时候，第一次访问根节点是不能够把根节点加入到结果集的，因为要把左右孩子全部访问到。所以需要封装一个新的类，包含一个boolean值，表示是与否已经访问过了。当为 true的时候，说明已经把它的左右节点都加入到stack里了，这个时候就可以把当前节点加入到结果集了。如果不加这个boolean值进行判断，那么当第二次访问到根节点的时候，你不知道跟节点的左右孩子是否已经访问过了，所以这个boolean是必须的。

2. 后续遍历的逆序。逆序的话就相对简单。先访问根节点，然后右孩子，再是左孩子。保存的结果使用linkedlist，这样每次插入都在头插入就可以了。

// public List<Integer> postorderTraversal(TreeNode root) {
// Stack<NTreeNode> stack = new Stack<>();
// List<Integer> result = new ArrayList<>();
// if(root != null){
// stack.push(new NTreeNode(root, false));
// }
// while(!stack.isEmpty()){
// NTreeNode node = stack.peek();
// if(node.visited){
// result.add(node.node.val);
// stack.pop();
// }else{
// if(node.node.right != null) stack.push(new NTreeNode( node.node.right, false));
// if(node.node.left != null) stack.push(new NTreeNode( node.node.left, false));
// node.visited = true;
// }
// }
// return result;
// }

// public List<Integer> postorderTraversal(TreeNode root) {
// Stack<TreeNode> stack = new Stack<>();
// List<Integer> result = new LinkedList<>();
//
// if(root != null) stack.push(root);
// while(!stack.isEmpty()){
// TreeNode node = stack.pop();
// if(node.left != null) stack.push(node.left);
// if(node.right != null) stack.push(node.right);
// result.add(0, node.val);
// }
// return result;
// }

代码：