Leetcode226/101/104/111之二叉树中的递归例题

二叉树中的递归例题

Leetcode226-翻转二叉树

• 给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点
• 输入：root = [4,2,7,1,3,6,9]
• 输出：[4,7,2,9,6,3,1]

//递归先序遍历的变形
public class L226 {
    public TreeNode invertTree(TreeNode root) {
        if(root==null){
            return null;
        }
        swap(root);
        invertTree(root.left);
        invertTree(root.right);

        return root;

    }

    public void swap(TreeNode root){
        TreeNode temp=root.left;
        root.left=root.right;
        root.right=temp;
    }
}

Leetcode101-对称二叉树

• 给你一个二叉树的根节点 root ， 检查它是否轴对称
• 输入：root = [1,2,2,3,4,4,3]
• 输出：true

//递归后序遍历变形
//本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等
public class L101 {
    public boolean isSymmetric(TreeNode root) {
        if(root==null){
            return true;
        }else{
            return isDuiChen(root.left,root.right);
        }
    }

    public boolean isDuiChen(TreeNode leftNode,TreeNode rightNode){
        if(leftNode==null && rightNode==null){
            return true;
        }
        if(leftNode==null || rightNode== null){
            return false;
        }
        if(leftNode.val!=rightNode.val){
            return false;
        }
        boolean outDuiChen=isDuiChen(leftNode.left,rightNode.right);
        boolean inDuiChen=isDuiChen(leftNode.right,rightNode.left);
        return outDuiChen&&inDuiChen;
    }
}

Leetcode104-二叉树的最大深度

• 给定一个二叉树，找出其最大深度。
• 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
• 给定二叉树 [3,9,20,null,null,15,7]
• 返回它的最大深度 3

public class L104 {
    //递归法后序遍历
    public int maxDepth1(TreeNode root) {
        return getDepth(root);
    }

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

    //递归法前序遍历
    int finalRes=1;
    public int maxDepth2(TreeNode root) {
        if(root==null){
            return 0;
        }
        getDepth2(root,1);
        return finalRes;
    }

    public void getDepth2(TreeNode root,int depth){
        if(finalRes<depth){
            finalRes=depth;
        }
        if(root.left==null && root.right==null){
            return;
        }
        if(root.left!=null){
            depth++;
            getDepth2(root.left,depth);
            depth--;
        }
        if(root.right!=null){
            depth++;
            getDepth2(root.right,depth);
            depth--;
        }
    }


    //迭代法
    public int maxDepth3(TreeNode root) {
        if (root==null)
            return 0;
        else {
            return order(root);
        }
    }


    public int order(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        int max=0;
        while (!queue.isEmpty()) {
            max++;
            int currentLevelSize = queue.size();
            for (int i = 0; i < currentLevelSize; i++) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        return max;
    }
}

Leetcode111-二叉树的最小深度

• 给定一个二叉树，找出其最小深度。
• 输入：root = [3,9,20,null,null,15,7]
• 输出：2

//递归的变形
public class L111 {
    public int minDepth(TreeNode root) {
        if(root==null){
            return 0;
        }
        int leftDepth=minDepth(root.left);
        int rightDepth=minDepth(root.right);
        //如果左子树为空，右子树不为空，说明最小深度是 1 + 右子树的深度
        if (root.left == null) {
            return rightDepth + 1;
        }
        //同上
        if (root.right == null) {
            return leftDepth + 1;
        }
        return Math.min(leftDepth,rightDepth)+1;
    }
}

标签：Leetcode226,null,return,int,二叉树,例题,root,public
来源： https://www.cnblogs.com/fao99/p/16121575.html