代码随想录算法训练营第十二天|144. 二叉树的前序遍历 94. 二叉树的中序遍历 145. 二叉树的后序遍历

今日理论基础

二叉树理论基础篇

今日主要题目

144. 二叉树的前序遍历

94.二叉树的中序遍历

145. 二叉树的后序遍历

主要学习网址

代码随想录

做题思路与具体代码

题目一：144. 二叉树的前序遍历

做题思路一

第一种解法：递归遍历法，中左右顺序，递归十分方便

注意中间是添加，左右是接着递归就好了

具体代码

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
    //递归解法
    //初始化结果集
    List<Integer> result=new ArrayList<>();
    pre(root,result);
    return result;
    }
    //传入当前节点和结果集
    public  void pre(TreeNode x,List<Integer> result){
        //中左右的顺序
        if(x==null){
            return;
        }
        //中
        result.add(x.val);
        //左
        pre(x.left,result);
        //右
        pre(x.right,result);
    }
}

做题思路二

第二种解法:迭代遍历法，同样是中左右的顺序，用一个栈来维护，存入栈和出栈的顺序要记住

记得一开始就返回中间节点，存右边，再存左边，达到出栈是先出左边再出右边的效果

具体代码

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
    //首先定义结果集
    List<Integer> result=new ArrayList<Integer>();
    //定义栈
    Stack<TreeNode> stack=new Stack<>();
    //按中左右顺序，一开始就返回中间结点
    //先存入右结点，再存入左结点
    //达到出栈的顺序是先左后右的效果
    //如果一开始跟结点就为0,直接返回
    if(root==null){
        return result;
    }
    //先把根结点存入栈中
    stack.push(root);
    //开始往下迭代
    //如果stack不为空就一直循环下去
    while(!stack.isEmpty()){
        //先弹出,得到弹出的元素
        TreeNode now=stack.pop();
        //存入弹出元素的值
        result.add(now.val);
        //记住存入栈的是一整个结点
        //先存右边
        if(now.right!=null){
            //存入栈中
            stack.push(now.right);
        }
        //再存左边
        if(now.left!=null){
            //存入栈中
            stack.push(now.left);
        }
    }
    //返回结果
    return result;
    }
}

题目二：94. 二叉树的中序遍历

做题思路一

第一种解法：递归遍历法，左中右的顺序，与前序遍历不同的只是顺序而已

具体代码

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
 //递归解法
    //初始化结果集
    List<Integer> result=new ArrayList<>();
    mid(root,result);
    return result;
    }
    //传入当前节点和结果集
    public void mid(TreeNode x,List<Integer> result){
        //左中右的顺序
        if(x==null){
            return;
        }
        //左
        mid(x.left,result);
        //中
        result.add(x.val);
        //右
        mid(x.right,result);
    }
    
}

做题思路二

第二种解法：迭代遍历法，左中右的顺序，不同于前序遍历和后序遍历

特殊：这里要先遍历到最左下的节点，再开始往上遍历

(这里提醒一下要注意这些临界条件，也就是循环遍历的条件)

具体代码

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
     //中序遍历的规则是
     //左中右
     //需要一个指针，不断遍历到最左边下面
     //判断此时是不是为空，是的话就是最左边下面，是的话就重置这个点为刚存入栈中的结点,弹出这个节点，再把指针重置为这个节点的右侧节点
     //不为空的话就不是最左边下面，先向栈中存入此时不为空的结点，再向左走

     //定义结果集
     List<Integer> result=new ArrayList<>();
     //定义栈用来遍历
     Stack<TreeNode> stack=new Stack<>();
     //定义一个指针方便随时返回
     //一开始先指向根节点
     TreeNode cur=root;
     //进入循环
     //循环条件是指针此时不为0或者栈不为0
     //根据临界条件判断这个循环条件
    while(cur!=null||!stack.isEmpty()){
        //如果指针走到位置不为空
        if(cur!=null){
            //先存入栈中
            stack.push(cur);
            //继续往左下走
            cur=cur.left;

        }
        //指针走到位置为空
        else{
             //先重置节点为刚存入栈中的结点，并弹出
             cur=stack.pop();
             //加入结果集
             result.add(cur.val);
             //再把指针重置为这个节点的右侧节点
             cur=cur.right;
        }
    }
    return result;

    }
}

题目三：145. 二叉树的后序遍历

做题思路一

第一种解法：递归遍历法，左右中的顺序，与前序遍历不同的只是顺序而已

具体代码

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) { 
     //递归解法
    //初始化结果集
    List<Integer> result=new ArrayList<>();
    aft(root,result);
    return result;
    }
    //传入当前节点和结果集
    public void aft(TreeNode x,List<Integer> result){
        //左右中的顺序
        if(x==null){
            return;
        }
        //左
        aft(x.left,result);
        //右
        aft(x.right,result);
        //中
        result.add(x.val);
    }
}

做题思路二

第二种解法：迭代遍历法，左右中的顺序，与前序遍历基本一样，除了存入的时候是左右的顺序存储，然后实现输出的结果是中右左的效果，最后再反转集合就好

具体代码

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) { 
    //初始化结果集
    List<Integer> result=new ArrayList<>();
    //后序遍历顺序是为左右中
    //解决思路是,结果集按照中右左的顺序,跟前序遍历比较
    //最后反转数组
    //如果根节点为空，返回空结果集
    if(root==null){
        return result;
    }
   
    //初始化栈
    Stack<TreeNode> stack=new Stack<>();
    //先把根节点插入栈
    stack.push(root);
    //开始往下迭代
    //如果stack不为空就一直循环下去
    while(!stack.isEmpty()){
        //先弹出,得到弹出的元素
        TreeNode now=stack.pop();
        //存入弹出元素的值
        result.add(now.val);
        //记住存入栈的是一整个结点
        //先存左边
        if(now.left!=null){
            //存入栈中
            stack.push(now.left);
        }
        //再存右边
        if(now.right!=null){
            //存入栈中
            stack.push(now.right);
        }
    }
    //反转链表
    Collections.reverse(result);
    //返回结果
    return result;
}
}