LeetCode树简单题合集(104、111、100、101、144、94、145)

一、104二叉树最大深度

解法一：递归

    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftDepth = maxDepth(root.left);
        int rightDepth = maxDepth(root.right);
        return Math.max(leftDepth, rightDepth) + 1;
    }

或者用三目运算符 ：

public int maxDepth(TreeNode root) {
        return root == null ? 0 : Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }

二、101二叉树的最小深度 

分析：

        1.递归的终止条件为：如果该节点无左子树也无右子树，即为叶子节点，返回result=0；     

        2.   如果不是叶子节点，又可以分为两种：一种是既有左子树也有右子树，则返回两者中较小的高度再加一；一种是只有其中一者，则返回两者中较大的高度再加一。

    public static int minDepth(TreeNode root) {
        int result = 0;
        if(root == null)return 0;

        int left = minDepth(root.left)+1;
        int right = minDepth(root.right)+1;

        if( root.left !=null && root.right!=null){
            result = Math.min(left,right);
        }else {
            result = Math.max(left,right);
        }
        return result;
    }

三、100相同的树

解法一：递归（深度优先）

        力扣官方解答：如果两个二叉树都为空，则两个二叉树相同。如果两个二叉树中有且只有一个为空，则两个二叉树一定不相同。如果两个二叉树都不为空，那么首先判断它们的根节点的值是否相同，若不相同则两个二叉树一定不同，若相同，再分别判断两个二叉树的左子树是否相同以及右子树是否相同。这是一个递归的过程，因此可以使用深度优先搜索，递归地判断两个二叉树是否相同。

    public boolean isSameTree(TreeNode p, TreeNode q) {
        if (p == null && q == null) {
            return true;
        } else if (p == null || q == null) {
            return false;
        } else if (p.val != q.val) {
            return false;
        } else {
            return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
        }
    }

四、101对称二叉树

解法一：递归

        这一题跟上一题类似，把根节点的左孩子跟右孩子想象为两颗子树，再比较他们是否镜像对称。

    public boolean isSymmetric(TreeNode root) {
        return isSameTree(root.left,root.right);
    }
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if (p == null && q == null) {
            return true;
        } else if (p == null || q == null) {
            return false;
        } else if (p.val != q.val) {
            return false;
        } else {
            return isSameTree(p.left, q.right) && isSameTree(p.right, q.left);
        }
    }

五、二叉树的前(144)中(94)后(145)遍历

简单的递归：

        前序：

    List<Integer> list = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
       
        if(root==null)return list;

        list.add(root.val);
        preorderTraversal(root.left);
        preorderTraversal(root.right);


        return list;
    }

        中序：

    List<Integer> list = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
       
        if(root==null)return list;

        
        preorderTraversal(root.left);
        list.add(root.val);
        preorderTraversal(root.right);


        return list;
    }

        后序：

    List<Integer> list = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {

        if(root==null)return list;


        preorderTraversal(root.left);
        preorderTraversal(root.right);
        list.add(root.val);

        return list;
    }

非递归：画图去理解一下 不难理解

    //前序
    public static List<Integer> preOrder(TreeNode root){
        List<Integer> list = new ArrayList();
        Stack<TreeNode> stack = new Stack();
        TreeNode cur = root;
        while(cur!=null || !stack.isEmpty()){
            while(cur!=null){
                stack.push(cur);
                list.add(cur.val);
                cur=cur.left;
            }
            cur = stack.pop();
            cur = cur.right;
        }
        return list;
    }

    //中序
    public List<Integer> inorderTraversal(TreeNode root) {
        if(root == null){
            return new ArrayList();
        }
        List<Integer> list = new ArrayList();
        Stack<TreeNode> stack = new Stack();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            while(cur!=null){
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.pop();
            list.add(cur.val);
            cur = cur.right;
        }
        return list;
    }

    //后序
    public static List<Integer> postOrder(TreeNode root){
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> list = new ArrayList<>();
        TreeNode cur = root;
        TreeNode p = null;//用来记录上一节点
        while(!stack.isEmpty() || cur != null){
            while(cur != null){
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.peek();

            if(cur.right == null || cur.right == p){
                list.add(cur.val);
                stack.pop();
                p = cur;
                cur = null;
            }else{
                cur = cur.right;
            }

        }
        return list;
    }