LeetCode-Binary Tree Postorder Traversal&Binary Tree Preorder Traversal

渣渣程序员要开始刷题了，第一天就被自己傻哭了

leetcode上的二叉树前序和后序遍历。

尼玛，已经忘了前序和后序什么的是怎么个意思了，百度之后发现是说遍历时访问根的顺序，先访问根就是前序，以此类推。

妈蛋，说递归的遍历是trivial的，trivial（有道说是琐碎的意思，琐碎你妹）啥意思都不懂，你还要叫我去用循环作遍历，简直不给活路。

用循环怎么做树的遍历呢，应该就得模拟人遍历时的过程吧。以前看过一句话说，递归是适合程序员的思维的，而循环更体现了机器的执行过程，记得不是很清楚的，循环其实在某种程度上是比递归的效率高的，因为少了函数频繁调用的时间开销，而且也减少了函数上下文的空间开销，但都说了好理解，所以该递归还是递归吧。妈蛋的leetcode要我循环，只有思考下了。

好吧思考了一下没结果，百度之，-  -。这种大众问题没啥好一直纠结的，反正都是被做烂了的了。看看别人的思路，大概瞅了一眼是用栈来做存储，模拟人进行遍历时的操作，好开始写代码。

后序遍历（因为是先刷的这道，但后序是比较麻烦的，因为要单独构造一个结构来存左右儿子是否都已经遍历了），先上代码：

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
class TreeNodeTag{
	TreeNode node;
	char tag;
	TreeNodeTag(TreeNode node){
		this.node = node;
	}
}
public class Solution {
	public List<Integer> postorderTraversal(TreeNode root) {
		List<Integer> list = new ArrayList<Integer>();
		Stack<TreeNodeTag> stack = new Stack<TreeNodeTag>();
		TreeNode p = root;
		TreeNodeTag nodeTag = null;
		while(p != null || !stack.isEmpty()){
			while( p != null){
				nodeTag = new TreeNodeTag(p);
				nodeTag.tag = 'L';
				stack.push(nodeTag);
				p = p.left;
			}
			while(!stack.isEmpty() && stack.lastElement().tag == 'R'){
				nodeTag = stack.pop();
				list.add(nodeTag.node.val);
			}
			if(!stack.empty()){
				nodeTag = stack.lastElement();
				nodeTag.tag = 'R';
				p = nodeTag.node.right;
			}
		}
		return list;
	}
}

其实代码是直接按照网上给的代码照搬来的，起初都看不懂这while，if的是个啥意思，看着不是很明白，敲进去，调试一步一步看着，大概能看懂了。

p变量用来存当前处理的节点，进入第一个while循环，如果p不为空则一直循环，第一个while循环一直先左下遍历，将节点封装压入栈中，然后第一个while结束；进入第二个while，如果栈顶元素的tag是'R'，说明它的左右子树都遍历完了，将它出栈，输出；进入第三个if，将栈顶的tag变成'R' ，将p指向栈顶的右节点。 简单来说第一个while循环就是遍历当前节点的作子树，第二个while是遍历根节点，第三个是遍历右子树。代码大致模仿了我们手工遍历时的过程，先沿着左下方一直往下，找到最左下的节点， 然后若果它有右节点就重复上述过程，左右都遍历了就输出根节点，其实往栈中压入值的过程只在第一个while中执行，也就是一直都是压入左子树的根节点的。

艾玛，用循环遍历树真是哭了，被自己蠢哭的。

先序遍历（相较后序就简单多了），代码奉上：

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;




public class Solution {
	public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
		Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode p = root;
        while(p != null || !stack.isEmpty()){
        	if(p != null){
        		stack.push(p);
        		list.add(p.val);
        		p = p.left;
        	}else{
        		p = stack.pop();
        		p = p.right;
        	}
        }
		return list;
    }
}

先序的代码就清晰简单多了，第一个while条件时一样的，直接先输出根节点，然后访问左子树，访问完了，p==null时，访问右子树，访问左子树过程中用stack记录访问的顺序就好，简单明了，很愉快！

哎，写个树遍历都这么纠结，看来今天不适合刷题。

GG

参考的大神链接奉上

------------------------------------------------------------华丽的分割线-------------------------------------------------------------------

无意中和实验室的师姐聊起在刷leetcode，碰到这道题被自己蠢哭得经历，师姐华丽得告诉我so easy，还指出后序遍历有另外一种做法，使用两个栈，特滚来献上代码。

后序遍历（双栈法），代码如下：

public ArrayList<Integer> postrderTraversal2(TreeNode root) {  
        Stack<TreeNode> s = new Stack<TreeNode>();  
        Stack<TreeNode> tmp = new Stack<TreeNode>();  
        ArrayList<Integer> result = new ArrayList<Integer>();  
        TreeNode node = root;  
        while(node != null || !s.isEmpty()){  
            while(node != null){  
                s.push(node);  
                tmp.push(node);  
                node = node.right;  
            }  
            if(!s.isEmpty()){  
                node = s.pop();  
                node = node.left;  
            }  
        }  
        while(!tmp.isEmpty()){  
            result.add(tmp.pop().val);  
        }  
        return result;  
    }

分析代码可以知道，栈temp只有入栈过程，它用来存储遍历的结果，最后直接按顺序出栈就是遍历结果了，栈s和第一种实现方法中的栈的用处类似，用来存储遍历的节点，不过由于后序遍历是“左右根”的顺序，理所应当应该是先根入栈，然后右边的节点，最后左边的节点，所以遍历时是一直往右边向下遍历的，跟着代码的思路自己跑一遍就能看懂代码的思路了。