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

二叉树的中序遍历：先中序遍历左子树，然后当前节点，再中序遍历右子树

设方法void inorderTree(TreeNode root, List<Integer> result) 为中序遍历root为根的二叉树，将遍历的结果存储在result参数中。

那么中序遍历左子树应该为inorderTree(root.left, result);

中序遍历右子树则为inorderTree(root.right, result);

即左中右

递归解法如下：

//中序遍历
public List<Integer> inorderTraversal(TreeNode root) {
	List<Integer> result = new ArrayList<>();
	inorderTree(root, result);
	return result;
}

//明确递归函数的定义：中序遍历root节点，将遍历结果存入result中
private void inorderTree(TreeNode root, List<Integer> result) {
	if(root==null) {
		return;
	}
	
	//中序遍历左子树
	inorderTree(root.left, result);
	
	//当前节点
	result.add(root.val);
	
	//中序遍历右子树
	inorderTree(root.right, result);
	
}

同理：前序遍历是先遍历当前节点，然后前序遍历左子树，再前序遍历右子树，即中左右

//前序遍历
public List<Integer> preorderTraversal(TreeNode root) {
	List<Integer> result = new ArrayList<>();
	preorderTree(root, result);
	return result;
}

//明确递归函数的定义：前序遍历root节点，将遍历结果存入result中
private void preorderTree(TreeNode root, List<Integer> result) {
	if(root==null) {
		return;
	}
	
	//当前节点
	result.add(root.val);
	
	//前序遍历左子树
	preorderTree(root.left, result);
	
	//中序遍历右子树
	preorderTree(root.right, result);
}

后序遍历：先后序遍历左子树，再后序遍历右子树，最后遍历当前节点，即左右中

//后序遍历
public List<Integer> postorderTraversal(TreeNode root) {
	List<Integer> result = new ArrayList<>();
	postorderTree(root, result);
	return result;
}

//明确递归函数的定义：前序遍历root节点，将遍历结果存入result中
private void postorderTree(TreeNode root, List<Integer> result) {
	if(root==null) {
		return;
	}
	
	//前序遍历左子树
	postorderTree(root.left, result);
	
	//中序遍历右子树
	postorderTree(root.right, result);
	
	//当前节点
	result.add(root.val);
}

前序遍历迭代算法，使用栈来实现：

//非递归的前序遍历，借助栈来实现
public List<Integer> preorderTraversal(TreeNode root) {
	
	if(root==null) {
		return new ArrayList<>();
	}
	
	List<Integer> result = new ArrayList<>(); 
	Stack<TreeNode> stack = new Stack<>();
	
	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;
}

中序遍历：迭代算法

public List<Integer> inorderTraversal(TreeNode root) {
	List<Integer> result = new ArrayList<>();
	Stack<TreeNode> stack = new Stack<TreeNode>();
	TreeNode node = root;
    while (!stack.isEmpty() || node != null) {
        while (node != null) {
            stack.push(node);
            node = node.left;
        }
        TreeNode popNode = stack.pop();
        result.add(popNode.val);
        node = popNode.right;
    }
	
	return result;
}

后续遍历：迭代算法

//非递归的前序遍历，借助栈来实现
public List<Integer> postorderTraversal(TreeNode root) {
	
	if(root==null) {
		return new ArrayList<>();
	}
	
	List<Integer> result = new ArrayList<>();
	Stack<TreeNode> stack = new Stack<TreeNode>();
	TreeNode node = root;
	TreeNode pre = null;
    while (!stack.isEmpty() || node != null) {
        while (node != null) {
            stack.push(node);
            node = node.left;
        }
        TreeNode sNode = stack.peek();
        if (sNode.right == null || pre == sNode.right) {
            stack.pop();
            pre = sNode;
            result.add(sNode.val);
        } else {
        	node = sNode.right;
        }
    }
    return result;
}