翻转二叉树 LeetCode 226

题目链接：[LeetCode 102 - 中等]

思路

沿着根节点，将左右的结点反转

迭代（借助队列）：

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root==null)return root;
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(root);

        while(!que.isEmpty()){
            int len = que.size();
            while(len>0){
                TreeNode node = que.poll();
                if(node.left!=null && node.right!=null){
                    TreeNode tmp = node.left;
                    node.left = node.right;
                    node.right = tmp;
                    que.offer(node.left);
                    que.offer(node.right);
                }else if(node.left!=null){
                    node.right=node.left;
                    node.left = null;
                    que.offer(node.right);
                }else if(node.right!=null){
                    node.left=node.right;
                    node.right=null;
                    que.offer(node.left);
                }
                len--;
            }
        }
        return root;
    }
}

对称二叉树 LeetCode 101

题目链接：[LeetCode 101 - 简单]

思路

两种方式：递归and遍历 三种判断非对称二叉树的可能性：①左子树为空②右子树为空③左右子树的数值不一致

迭代（借助队列）：

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root==null)return true;
        Deque<TreeNode> que = new LinkedList<>();
        que.offerFirst(root.left);
        que.offerLast(root.right);
        while(!que.isEmpty()){
            TreeNode leftNode = que.pollFirst();
            TreeNode rightNode = que.pollLast();
            if(leftNode==null && rightNode==null){
                continue;
            }
            if(leftNode==null || rightNode==null || leftNode.val!=rightNode.val){
                return false;
            }
            que.offerFirst(leftNode.left);
            que.offerFirst(leftNode.right);
            que.offerLast(rightNode.right);
            que.offerLast(rightNode.left);
        }
        return true;
    }
}

递归：

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return check(root.left,root.right);
    }
    private boolean check(TreeNode rightNode,TreeNode leftNode){
        if(leftNode==null && rightNode==null){
            return true;
        }
        if((leftNode==null && rightNode!=null)||(leftNode!=null && rightNode==null)||leftNode.val!=rightNode.val){
            return false;
        }
        return check(leftNode.left,rightNode.right)&&check(leftNode.right,rightNode.left);
    }
}

完全二叉树的节点个数 LeetCode 222

题目链接：[LeetCode 222 - 简单]

思路

一种是通用的计算节点个数，另一种是针对于完全二叉树的做法。

递归：

class Solution {
    public int countNodes(TreeNode root) {
        if(root==null)return 0;
        return countNodes(root.left)+countNodes(root.right)+1;
    }
}

仅仅针对于完全二叉树：

class Solution {
    public int countNodes(TreeNode root) {
        if(root==null)return 0;
        TreeNode left = root.left;
        TreeNode right = root.right;
        int leftDepth = 0,rightDepth = 0;
        while(left!=null){
            left = left.left;
            leftDepth++;
        }
        while(right!=null){
            right = right.right;
            rightDepth++;
        }
        if(rightDepth==leftDepth){
            return (2<<leftDepth) - 1;
        }
        return countNodes(root.left) + countNodes(root.right) + 1;
    }
}

平衡二叉树 LeetCode 110

题目链接：[LeetCode 110 - 简单]

思路

判断左右子树的高度。

递归：

class Solution {
    public boolean isBalanced(TreeNode root) {
        return getHeight(root)!=-1;
    }
    private int getHeight(TreeNode node){
        if(node==null){
            return 0;
        }
        int leftHeight = getHeight(node.left);
        if(leftHeight==-1){
            return -1;
        }
        int rightHeight = getHeight(node.right);
        if(rightHeight==-1){
            return -1;
        }
        if(Math.abs(leftHeight-rightHeight)>1){
            return -1;
        }
        return Math.max(leftHeight,rightHeight)+1;
    }
}