Leetcode简单题思路（101-200）

101. 对称二叉树

思路：1. 递归。

如果同时满足下面的条件，两个树互为镜像：

1. 它们的两个根结点具有相同的值。
2. 每个树的右子树都与另一个树的左子树镜像对称。

public boolean isSymmetric(TreeNode root) {
    return isMirror(root, root);
}

public boolean isMirror(TreeNode t1, TreeNode t2) {
    if (t1 == null && t2 == null) return true;
    if (t1 == null || t2 == null) return false;
    return (t1.val == t2.val)
        && isMirror(t1.right, t2.left)
        && isMirror(t1.left, t2.right);
}

2. 迭代。

队列，

除了递归的方法外，我们也可以利用队列进行迭代。队列中每两个连续的结点应该是相等的，而且它们的子树互为镜像。最初，队列中包含的是 root 以及 root。该算法的工作原理类似于 BFS，但存在一些关键差异。每次提取两个结点并比较它们的值。然后，将两个结点的左右子结点按相反的顺序插入队列中。当队列为空时，或者我们检测到树不对称（即从队列中取出两个不相等的连续结点）时，该算法结束。

public boolean isSymmetric(TreeNode root) {
    Queue<TreeNode> q = new LinkedList<>();
    q.add(root);
    q.add(root);
    while (!q.isEmpty()) {
        TreeNode t1 = q.poll();
        TreeNode t2 = q.poll();
        if (t1 == null && t2 == null) continue;
        if (t1 == null || t2 == null) return false;
        if (t1.val != t2.val) return false;
        q.add(t1.left);
        q.add(t2.right);
        q.add(t1.right);
        q.add(t2.left);
    }
    return true;
}

 

104. 二叉树最大深度

public int maxDepth(TreeNode root) {
    if (root == null) return 0;

    return Math.max(maxDepth(root.left),maxDepth(root.right))+1;
}

 

107. 二叉树层次遍历

题：给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

思路：队列，每次遍历存储下一层的节点个数nextNum，每次循环结束时将nextNum的值赋给curNum。

从叶子节点保存可以使用：Collections.reverse(list)来实现

while (curNum > 0) {
        node = queue.poll();
        tmp.add(node.val);
        curNum--;
        if (node.left != null) {
            nextNum++;
            queue.add(node.left);
        }
        if (node.right != null) {
            nextNum++;
            queue.add(node.right);
        }
    }
    order.add(tmp);
    curNum = nextNum;
}

Collections.reverse(order);

 

108. 将有序数组转化成平衡二叉树

题：将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

思路：其实是中序遍历的逆过程。递归地构造树

所以重点是：找到root节点！！！

由于是有序数组，且要形成的是平衡二叉树，一般中点就是root

1. 左右区间问题，直接用左闭右闭；2. 右移代替/2操作，防止溢出

递归+分治

public TreeNode sortedArrayToBST(int[] nums) {
    return sortedArrayToBST(nums,0,nums.length-1);
}

private TreeNode sortedArrayToBST(int[] nums, int start, int end) {
    if (start > end) return null;

    int mid = (start + end) >>> 1;

    TreeNode root = new TreeNode(nums[mid]);
    root.left = sortedArrayToBST(nums,start,mid-1);
    root.right = sortedArrayToBST(nums,mid+1,end);

    return root;
}

 

 

110. 平衡二叉树

题：给定一个二叉树，判断它是否是高度平衡的二叉树。本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

思路：递归。

递归三部曲（模板）：

找终止条件、找返回值、一次递归应该做什么。

1）终止条件：root == null，则一定返回true；

2）返回值：是平衡二叉树要满足两个条件：1左右子树都是平衡二叉树；2左右子树的高度差<=1。

所以要返回的其实是这两个值全部；

3）一次递归做什么：其实就是计算2）中的左右子树高度差以及判断分别是不是平衡树

注：如何返回两个值？其实可以想到除了返回值以外，还有成员变量可以在函数内更改（变相的返回）。

boolean res = true;
public boolean isBalanced(TreeNode root) {
    height(root);
    return res;
}
public int height(TreeNode root) {
    if (root == null) return 0;

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

    if (Math.abs(left-right) > 1) res = false;
    return Math.max(left,right);
}

 

 

111. 最小深度

叶子节点的定义是左孩子和右孩子都为 null 时叫做叶子节点
当 root 节点左右孩子都为空时，返回 1
当 root 节点左右孩子有一个为空时，返回不为空的孩子节点的深度
当 root 节点左右孩子都不为空时，返回左右孩子较小深度的节点值

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

    if (root.left == null && root.right == null) return 1;  //叶子节点

    int leftHeight = minDepth(root.left);
    int rightHeight = minDepth(root.right);

    if (root.left == null || root.right == null) {
        return leftHeight + rightHeight + 1; //其中有一个是0
    }

    return Math.min(leftHeight,rightHeight) + 1;
}

 

112. 路径总和

题：给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

思路：递归&#