力扣144 94 145 二叉树的前中后序遍历(深度优先搜索)

递归三要素:
(1)确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
(2)确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
(3)确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

以前序遍历为例：
(1)确定递归函数的参数和返回值：因为要打印出前序遍历节点的数值，所以参数里需要传入vector来放节点的数值，除了这一点就不需要再处理什么数据了也不需要有返回值，所以递归函数返回类型就是void。

public void preorder(TreeNode root, List<Integer> result)

(2)确定终止条件：在递归的过程中，如何算是递归结束了呢，当然是当前遍历的节点是空了，那么本层递归就要结束了，所以如果当前遍历的这个节点是空，就直接return。

if (root == null) {
　　return;
}

(3)确定单层递归的逻辑：前序遍历是中左右的循序，所以在单层递归的逻辑，是要先取中节点的数值。

result.add(root.val);
preorder(root.left, result);
preorder(root.right, result);

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

题目：给你二叉树的根节点root，返回它节点值的前序遍历。

示例：

输入：root = [1,null,2,3]
输出：[1,2,3]

// 前序遍历·递归·LC144_二叉树的前序遍历:根左右
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);
    }
}

//迭代法:用栈实现递归，出栈如果要满足根左右，入栈要先入右孩子，并且注意入栈时不是if else而是if if（同时有左右孩子）

class Solution {

    public List<Integer> preorderTraversal(TreeNode root) {

        List<Integer> res=new ArrayList<>();

        if(root==null){

            return res;

        }

        Stack<TreeNode> st=new Stack<>();

        st.push(root);

        while(!st.isEmpty()){

            TreeNode node=st.pop();

            res.add(node.val);//根

            if(node.right!=null){//右

                st.push(node.right);

            }

            if(node.left!=null){//左

                st.push(node.left);

            }

        }

        return res;

    }

}

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

   示例：

输入：root = [1,null,2,3]
输出：[1,3,2]

// 中序遍历·递归·LC94_二叉树的中序遍历：左根右
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        inorder(root,res);
        return res;
    }

    public void inorder(TreeNode root,List<Integer> res){
        if(root==null){
            return;
        }
        inorder(root.left,res);//左
        res.add(root.val);//根         //注意这一句
        inorder(root.right,res);//右
    }
}

//迭代法:用栈实现递归，由于访问顺序和处理顺序不同，中序遍历有另一套写法。
//用栈记录，指针遍历过的元素，当一路访问左孩子至叶子节点时，就要开始弹出栈里的元素了，然后再去访问经过的根结点的右孩子。

class Solution {

    public List<Integer> inorderTraversal(TreeNode root) {

        List<Integer> res=new ArrayList<>();

        if(root==null){

            return res;

        }

        Stack<TreeNode> st=new Stack<>();

        TreeNode cur=root;

        while(cur!=null||!st.isEmpty()){

            if(cur!=null){//左孩子不为空，接着往下找左孩子

                st.push(cur);

                cur=cur.left;

            }else{//一直到叶子节点,开始弹出

                cur=st.pop();

                res.add(cur.val);

                cur=cur.right;//然后再去找右孩子的左孩子

            }

        }

       return res;

    }

}

题目：给定一个二叉树的根节点root，返回它的后序遍历。

   示例：

输入：root = [1,null,2,3]
输出：[3,2,1]

// 后序遍历·递归·LC145_二叉树的后序遍历：左右根
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        inorder(root,res);
        return res;
    }

    public void inorder(TreeNode root,List<Integer> res){
        if(root==null){
            return;
        }
        inorder(root.left,res);//左       
        inorder(root.right,res);//右
        res.add(root.val);//根  
    }
}         

//迭代法:用栈实现递归，先序遍历是中左右，后续遍历是左右中，那么只需要调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后在反转result数组，输出的结果顺序就是左右中。

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res= new ArrayList<>();
        if(root==null){
            return res;
        }
        Stack<TreeNode> st=new Stack<>();
        st.push(root);
        while(!st.isEmpty()){
            TreeNode node=st.pop();
            res.add(node.val);//根
            if(node.left!=null){
                st.push(node.left);//左
            }
            if(node.right!=null){
                st.push(node.right);//右
            }
            //出栈：根右左
        }
        Collections.reverse(res);//反转：根右左-->左右根
        return res;
    }
} 

tips:

arraylist.add（int index，E element）
注：arraylist 是 ArrayList 类的一个对象。

参数说明：
    index（可选参数）- 表示元素所插入处的索引值
    element - 要插入的元素