二叉树前中后序遍历框架

遍历的方法有两种解法：递归和迭代

先序遍历：

1. 判空
2. 访问结点
3. 左孩子入栈（再次从1开始执行）
4. 右孩子入栈（再次从1开始执行）

中序遍历：

1. 判空
2. 左孩子入栈（再次从1开始执行）
3. 访问结点
4. 右孩子入栈（再次从1开始执行）

后序遍历：

1. 判空
2. 左孩子入栈（再次从1开始执行）
3. 右孩子入栈（再次从1开始执行）
4. 访问结点

1.递归框架：

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

    
    private void xxxoder(TreeNode root,List<Integer> res){
        if(root!=null){
            //前序遍历
            preoder(root.left,res);
            //中序遍历
            preoder(root.right,res);
            //后序遍历
        }
    }
}

实例：

//前序遍历递归
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        preoder(root,res);
        return res;
    }

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


  //递归方法求中序遍历
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        inorder(root,res);
        return res;
    }

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


//后序遍历递归
class Solution{
	public List<Integer> postorderTraversal(TreeNode root){
	List<Integer> res = new ArrayList<>();
	postorder(root,res);
	return res;	

}

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

}

2.迭代框架

public List<Integer> traversal(TreeNode root) {
    if (root == null) return new ArrayList<Integer>();
    
    TreeNode node = root;
    List<Integer> ret = new ArrayList<Integer>();
    
    Stack<TreeNode> stack = new Stack<TreeNode>();
    while(node != null || !stack.isEmpty()) {
        while (node != null) {
            stack.push(node);
            // 先序遍历 ret.add(node.val);
            node = node.left;
        }
        node = stack.pop();
        // 中序遍历
        node = node.right;
        // 后序遍历
    }
    return ret;
}

实例：

//前序遍历迭代写法
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        if(root == null) return new ArrayList<Integer>();

		TreeNode node = root;
		List<Integer> ret = new ArrayList<Integer>();
		Stack<TreeNode> stack = new Stack<TreeNode>();

		while(node!=null || !stack.isEmpty()){
			while(node != null){
				stack.push(node);
				//前序遍历
				ret.add(node.val);
				node = node.left;
			}
			node = stack.pop();
			node = node .right;
		}
		return ret;
		
}
}

先序遍历思路
1.判断当前节点或用户栈是否为空，若不为空，执行下面操作，否则全部流程结束。
2.判断当前节点是否为空，若为空，则执行下一步，若不为空则访问当前节点并将当前节点入用户栈
3.更新当前节点为用户栈出栈节点
4.更新当前节点为其右孩子节点，进入下一个循环

//中序遍历迭代
class Solution{
	public List<Integer> inorderTraval(TreeNode root){
		if(root == null) return new ArrayList<Integer>();

		List<Integer> res = new ArrayList<Integer>();
		Stack<TreeNode> stack = new Stack<>();

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

}

后序遍历需要注意右孩子是否被访问过

//后序遍历迭代法
class Solution{
	public List<Integer> postderTraval(TreeNode root){
		if(root == null) return new ArrayList<Integer>();

		List<Integer> res = new ArrayList<Integer>();
		Stack<TreeNode> stack = new Stack<>();
		
		TreeNode cur = root;
		TreeNode last = null;
		
		while(cur!= null || !stack.isEmpty()){
			while(cur!=null){
				stack.push(cur);
				cur=cur.left;
			}
			cur=stack.peek();
			if(cur.right == null || cur.right == last){ // 右孩子为空或者访问过了
				res.add(cur.val);
				stack.pop();
				last = cur;
				cur=null;
			}else{
				cur=cur.right;
			}
	
		}
		return res;
	}

}

后序遍历思路

1.判断当前节点或用户栈是否为空，若不为空，执行下面操作，否则全部流程结束。
2.判断当前节点是否为空，若为空，则执行下一步，若不为空则将当前节点入用户栈
3. 更新当前节点为用户栈出栈节点
4. 当右孩子为空及右孩子被访问过时，访问当前节点，更新当前节点为空，为下一步的出栈作准备
5.当右孩子不为空并且右孩子未被访问过，则更新当前节点为右孩子

• 题目参考链接：

144 二叉树的前序遍历
94. 二叉树的中序遍历
145. 二叉树的后序遍历