LeetCode - 94.二叉树的前、中、后序遍历（不咋会，需要多看）重点！！

二叉搜索树，也称二叉搜索树、有序二叉树（Ordered Binary Tree）、 排序二叉树（Sorted Binary Tree），是指一棵空树或者具有下列性质的 二叉树：

1. 左子树上所有结点的值均 小于 它的根结点的值；
2. 右子树上所有结点的值均 大于 它的根结点的值；
3. 以此类推：左、右子树也分别为二叉查找树。 （这就是 重复性！）

中序遍历：升序排列

94. 二叉树的中序遍历

题目：
给定一个二叉树，返回它的中序 遍历。

==============================
前序遍历：打印 - 左 - 右
中序遍历：左 - 打印 - 右
后序遍历：左 - 右 - 打印

方法一： 递归

终止条件：当前节点为空时
函数内：递归的调用左节点，打印当前节点，再递归调用右节点

时间复杂度：O(n)
空间复杂度：O(h)，h 是树的高度

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        inorder(root, res);
        return res;
    }

    public void inorder(TreeNode root, List<Integer> res) {
    	//终止条件
        if (root == null) {
            return;
        }
        //遍历 root 节点的左子树，然后将root 节点的值加入答案
        inorder(root.left, res);
        //遍历到 root节点答案，把当前节点加入到集合中
        res.add(root.val);
        //来遍历 root 节点的右子树即可，递归终止的条件为碰到空节点
        inorder(root.right, res);
    }
}

方法二： 栈

class solution{
	public List<Integer> inorderTraversal(TreeNode root){
		List<Integer> res = new ArrayList<Integer>();
		Deque<TreeNode> stk = new LinkedList<TeeeNode>();
		//终止条件
		while(root != null || !stk.isEmpty()){
			//当不再有节点的时候就终止遍历，把栈中的元素返回答案
			while(root != null){
				stk.push(root);
				root = root.left;
			}
			root = stk.pop();
			res.add(root.val);
			root = root.right;
		}
		return res;
	}
}

方法三： Morris 中序遍历

不会啊。。。。。。。。

144. 二叉树的前序遍历

方法一： 递归

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        preorder(root,res);
        return res;
    }
    public void preorder(TreeNode root,List<Integer> res){
        if(root == null)
            return;
        res.add(root.val);
        preorder(root.left,res);
        preorder(root.right,res);
    }
}

方法二： 栈

从根节点开始，每次迭代弹出当前栈顶元素，并将其孩子节点压入栈中，先压右孩子再压左孩子。

输出到最终结果的顺序按照 Top->Bottom 和 Left->Right，符合前序遍历的顺序。

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

        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode node = root;
        while (!stack.isEmpty() || node != null) {
            while (node != null) {
                res.add(node.val);
                stack.push(node);
                node = node.left;
            }
            node = stack.pop();
            node = node.right;
        }
        return res;
    }
}

 public List<Integer> preOrderTraversal(TreeNode root) {
        LinkedList<Integer> res = new LinkedList<>();
        LinkedList<TreeNode> stk = new LinkedList<>();
        if (root == null){
            return res;
        }

        //先把根节点加入栈
        stk.add(root);
        while (!stk.isEmpty()){
            //如果栈不为空，则返回栈中最后一个元素到答案的list中
            TreeNode node = stk.pollLast();
            res.add(node.val);
            if (node.right != null){
                stk.add(node.right);
            }
            if (node.left != null){
                stk.add(node.left);
            }

        }
        return res;
    }

145. 二叉树后序遍历

方法一： 递归

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        postorder(root,res);
        return res;
    }
    public void postorder(TreeNode root,List<Integer> res){
        if(root == null)
            return;
        postorder(root.left,res);
        postorder(root.right,res);
        res.add(root.val);
    }
}

方法二：迭代

public List<Integer> postOrderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root==null){
            return res;
        }
        Deque<TreeNode> stack = new LinkedList<>();
        TreeNode prev = null;
        while(root != null || !stack.isEmpty()){
            while (root!=null){
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            if (root.right == null || root.right == prev){
                res.add(root.val);
                prev = root;
                root = null;
            }else {
                stack.push(root);
                root = root.right;
            }

        }
        return res;
    }