二叉树part01

二叉树part01

****今日内容：

●  理论基础

●  递归遍历

1. 理论基础

了解 二叉树的种类，存储方式，遍历方式 以及二叉树的定义

2.递归遍历

递归：一直调用同一个函数，不断地指针下去
递归确定的三大要素：
1.确定递归函数的参数和返回值
2.确定终止条件
3.确定单层递归的逻辑

2.1 144.二叉树的前序遍历

144. 二叉树的前序遍历

/**
 * 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        //思路：前序遍历是中左右
        //看完代码随想录后
        //递归的方式，用一个函数，里面分别进行中左右的逻辑函数，重新返回到函数里面进行存储，和进行下一轮的中左右判断
        //定义一个集合，存放结果
        List<Integer> list=new ArrayList<>();
        digui(root,list);
        return list;

    }
    public void digui(TreeNode root,List<Integer> list){
            //首先先判断根节点是否为空，如果为空，直接不用存了，函数结束
            if(root==null){
                return;
            }
            //不为空，那我们将这个节点值存进数组中
            list.add(root.val);//第一次存进去的是根节点，也就是中处的位置
            //然后就是判断根节点的左子节点要不要存进去了//就用一个函数返回回去，重新进入这个外面的函数
            //调用该函数，将现在的子左节点和数组传进去判断
            digui(root.left,list);
            //如果这个子左节点为空，那么就会到上面那个return，结束掉此函数的调用
            //继续下面的逻辑
            digui(root.right,list);
        }
}
/*
递归：一直调用同一个函数，不断地指针下去
递归确定的三大要素：
1.确定递归函数的参数和返回值
2.确定终止条件
3.确定单层递归的逻辑
 */

2.2 94.二叉树的中序遍历

94. 二叉树的中序遍历

/**
 * 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        //思路：中序遍历，也就是左中右逻辑
        //也一样用到的是递归
        //比较二叉树的前序遍历不同的是，存进数组的位置不一样

        //定义一个数组集合
        List<Integer> list=new ArrayList<>();
        //调用递归函数
        digui(root,list);
        //返回数组集合
        return list;
    }
    //定义一个递归函数
    public void digui(TreeNode root,List<Integer> list){
        if(root==null){
            return;
        }
        //根节点不为空的情况
        //首先因为我们这道题是按照左中右进行排序
        //所以我们首先先判断根节点的左子树的节点是否为空，不为空，我们就将这个节点值存进数组
        digui(root.left,list);
        list.add(root.val);
        digui(root.right,list);
    }
}

2.3 145.二叉树的后序遍历

145. 二叉树的后序遍历

/**
 * 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
         //定义一个数组集合
        List<Integer> list=new ArrayList<>();
        //调用递归函数
        digui(root,list);
        //返回数组集合
        return list;
    }
    //定义一个递归函数
    public void digui(TreeNode root,List<Integer> list){
        if(root==null){
            return;
        }
        //排除根节点不为空的情况
        //首先因为我们这道题是按照左右中进行排序
        //就是深度优先，左边全部到底再来其他的
        //所以我们首先先判断根节点的左子树的节点是否为空，不为空，我们就将这个节点值存进数组
        digui(root.left,list);//进行完这个函数
        digui(root.right,list);//再进行这个函数
        list.add(root.val);//最后是自己本函数的逻辑
    }
}
/**
 * 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;
 *     }
 * }
 */