树的leetcode题目

101. 对称二叉树

Difficulty: 简单

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

    1
   / \
  2   2
 / \ / \
3  4 4  3

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

    1
   / \
  2   2
   \   \
   3    3

进阶：

你可以运用递归和迭代两种方法解决这个问题吗？

Solution

  public boolean isSymmetric(TreeNode root) {
    if(root==null){
        return false;
    }
  
    return helper(root.left,root.right);
}
public boolean helper(TreeNode left,TreeNode right){
    if(left==null&&right==null){
        return true;
    }
    if(left==null||right==null){
        return false;
    }
    return helper(left.left,right.right)&&helper(left.right,right.left)&&(left.val==right.val);

}
​

98. 验证二叉搜索树

Difficulty: 中等

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

• 节点的左子树只包含小于当前节点的数。
• 节点的右子树只包含大于当前节点的数。
• 所有左子树和右子树自身必须也是二叉搜索树。

示例 1:

输入:
    2
   / \
  1   3
输出: true

示例 2:

输入:
    5
   / \
  1   4
     / \
    3   6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
     根节点的值为 5 ，但是其右子节点值为 4 。

Solution

Language: **java

  List<Integer> res = new ArrayList<>();

    public boolean isValidBST(TreeNode root) {
        res = inorderTraversal(root);
        for (int i = 1; i < res.size(); i++) {
            if (res.get(i)<=res.get(i-1)){
                return false;
            }
        }
        return true;
    }

    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        helper(root, res);
        return res;
    }

    public void helper(TreeNode root, List<Integer> res) {
        if (root != null) {
            if (root.left != null) {
                helper(root.left, res);
            }
            res.add(root.val);
            if (root.right != null) {
                helper(root.right, res);
            }
        }
    }

   long pre = Long.MIN_VALUE;

    public boolean isValidBST(TreeNode root) {
        if (root != null) {
            if (!isValidBST(root.left)) return false;
            if (root.val <= pre) return false;
            pre = root.val;
            if (!isValidBST(root.right)) return false;
        }
        return true;
    }

199. 二叉树的右视图

Difficulty: 中等

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例:

输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:

   1            <---
 /   \
2     3         <---
 \     \
  5     4       <---

Solution

Language: 全部题目

point:二叉树层序遍历；然后判断判断每一层的元素的下标如果是当前层的size-1;则把这个添加进res;

    public List<Integer> rightSideView(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<Integer> res = new ArrayList<>();
        if (root != null) {
            queue.add(root);
        }
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode root1 = queue.poll();
                if (root1.left != null) {
                    queue.add(root1.left);
                }
                if (root1.right != null) {
                    queue.add(root1.right);
                }
                if (i == size - 1) {
                    res.add(root1.val);
                }
            }
        }
        return res;
    }

69. x 的平方根

Difficulty: 简单

实现 int sqrt(int x) 函数。

计算并返回 x 的平方根，其中 x 是非负整数。

由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

示例 1:

输入: 4
输出: 2

示例 2:

输入: 8
输出: 2
说明: 8 的平方根是 2.82842..., 
     由于返回类型是整数，小数部分将被舍去。

Solution

Language: 全部题目

class Solution {
    public int mySqrt(int x) {
    if (x < 2) return x;

    long num;
    int pivot, left = 2, right = x / 2;
    while (left <= right) {
      pivot = left + (right - left) / 2;
      num = (long)pivot * pivot;
      if (num > x) right = pivot - 1;
      else if (num < x) left = pivot + 1;
      else return pivot;
    }

    return right;
  }
}

160. 相交链表

Difficulty: 简单

编写一个程序，找到两个单链表相交的起始节点。

如下面的两个链表**：**

在节点 c1 开始相交。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Reference of the node with value = 2
输入解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
解释：这两个链表不相交，因此返回 null。

注意：

• 如果两个链表没有交点，返回 null.
• 在返回结果后，两个链表仍须保持原有的结构。
• 可假定整个链表结构中没有循环。
• 程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

Solution

Language: 全部题目

    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA == null || headB == null) return null;
    
    ListNode a = headA;
    ListNode b = headB;

 //if a & b have different len, then we will stop the loop after second iteration
    while( a != b){
    	//for the end of first iteration, we just reset the pointer to the head of another linkedlist
        a = a == null? headB : a.next;
        b = b == null? headA : b.next;    
    }
    
    return a;
    }

113. 路径总和 II

Difficulty: 中等

给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。

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

示例:
给定如下二叉树，以及目标和 sum = 22，

              5
             / \
            4   8
           /   / \
          11  13  4
         /  \    / \
        7    2  5   1

返回:

[
   [5,4,11,2],
   [5,8,4,5]
]

Solution

Language: 全部题目

        public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        dfs2(root, res, "");
        return res;
    }

    public void dfs2(TreeNode root, List<String> res, String s) {
        if (root == null) {
            return;
        }
        if (root.left == null && root.right == null) {
            res.add(s+root.val);
            return;
        }
       if(root.left!=null){
            dfs2(root.left, res, s+root.val + "->");
       } 
       if(root.right!=null){
        dfs2(root.right, res, s+root.val + "->");

       }
    }