各位朋友们，大家好！今天我为大家分享的是关于二叉树leetcode刷题的第二篇，我们一起来看看吧。

1.对称二叉树

leetcode之对称二叉树（难度：简单）

题目要求

给你一个二叉树的根节点 root ， 检查它是否轴对称。

/**
 * 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 boolean isSymmetric(TreeNode root) {

    }
}

示例

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

做题思路

这道题我们需要先判断二叉树的左子树的结构与右子树的结构是否相同，如果不同就说明不对称，如果结构相同我们就看左子树的左树与右子树的右树是否相同，不相同就返回false，相同就继续看左子树的右树与右子树的左树是否相同。因为题目给我们方法只有一个参数，所以我们需要自己写一个两个参数的方法，我们自己写的方法是实现判断的主体，题目给的方法我们只是用来接收我们自己写的方法的返回值。

代码实现

/**
 * 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 boolean isSymmetric(TreeNode root) {
    //当根节点为null时我们规定返回true
        if(root == null) {
            return true;
        }
        if(isSymmetricChild(root.left,root.right)) {
            return true;
        }
        return false;
    }

    public boolean isSymmetricChild(TreeNode leftTree,TreeNode rightTree) {
    //判断左右子树结构是否相同
        if(leftTree == null || rightTree == null) {
            if(leftTree == null && rightTree == null) {
                return true;
            }else {
                return false;
            }
        }
        if(leftTree.val != rightTree.val) {
            return false;
        }
        return isSymmetricChild(leftTree.left,rightTree.right)
            && isSymmetricChild(leftTree.right,rightTree.left);
    }
}

2.二叉树的最大深度

leetcode之二叉树的最大深度（难度：简单）

题目要求

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

/**
 * 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 int maxDepth(TreeNode root) {

    }
}

示例

给定二叉树 [3,9,20,null,null,15,7]，

3

/
9 20
/
15 7
返回它的最大深度 3 。

做题思路

二叉树的最大深度是指左子树深度与右子树深度中较大的那个，我们先把问题简化


当root为null时返回0，然后继续前面的递归

返回root左子树的深度和右子树深度的较大值+1，因为左子树和右子树的深都为0，所以返回1

这里右子树也是如此，返回1

返回1+1+1 = 3

代码实现

/**
 * 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 int maxDepth(TreeNode root) {
    //当root为null时返回0
        if(root == null) {
            return 0;
        }
    
        int leftDepth = maxDepth(root.left);
        int rightDepth = maxDepth(root.right);

		//返回leftDepth和rightDepth中深度较大的
        return leftDepth>rightDepth?(leftDepth+1):(rightDepth+1);
    }
}

3.翻转二叉树

leetcode之翻转二叉树（难度：简单）

题目要求

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

/**
 * 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 TreeNode invertTree(TreeNode root) {
}

示例

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

做题思路

我们需要将二叉树的左子树的左树跟右子树的右树交换，左子树的右树跟右子树的左树交换。

root向下走，知道走到root为null的时候停下，先走左树，然后是右树，最后是根。

root为null返回null，继续完成前面的递归

交换root的左右子树，因为这里root的左右子树都为null，所以也没交换

这里跟前面是一样的

如此这样的过程。

代码实现

/**
 * 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 TreeNode invertTree(TreeNode root) {
        if(root == null) {
            return null;
        }
        invertTree(root.left);
        invertTree(root.right);

        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;

        return root;
    }
}

4.平衡二叉树

leetcode之平衡二叉树（难度：简单）

题目要求

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

示例

输入：root = [3,9,20,null,null,15,7]
输出：true

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

输入：root = []
输出：true

做题思路

其实要想做出这个题，我们只需要对前面的求二叉树的最大深度稍微做出修改就可以了。我们不只是返回左右树中深度较大的子树，而是判断左右子树的深度的差的绝对值是否大于1，如果大于1就返回-1，小于等于1就返回左右子树中深度较大的子树的深度。

代码实现

/**
 * 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 int maxDepth(TreeNode root) {
    //当root为null时返回0，即使刚进来时root为null，也可以考虑到
        if(root == null) {
            return 0;
        }
        int leftTree = maxDepth(root.left);
        //我们在这里直接先进行判断，如果不符合就直接返回，可以减少时间的消耗
        if(leftTree < 0) {
            return -1;
        }
        int rightTree = maxDepth(root.right);
        if(rightTree < 0) {
            return -1;
        }
        if(Math.abs(leftTree-rightTree) <= 1) {
            return Math.max(leftTree,rightTree)+1;
        }else {
            return -1;
        }
    }

    public boolean isBalanced(TreeNode root) {
        if(maxDepth(root) < 0) {
            return false;
        }

        return true;
    }
}