OJ刷题Day2 · 判断根结点是否等于子结点之和 · 删除有序数组中的重复项 · 合并两个有序链表 · 数组中的第K个最大元素（中等题）

一、判断根结点是否等于子结点之和

给你一个 二叉树 的根结点 root，该二叉树由恰好 3 个结点组成：根结点、左子结点和右子结点。
如果根结点值等于两个子结点值之和，返回 true ，否则返回 false 。

示例 1：

输入：root = [10,4,6]
输出：true
解释：根结点、左子结点和右子结点的值分别是 10 、4 和 6 。
由于 10 等于 4 + 6 ，因此返回 true 。

示例 2：

输入：root = [5,3,1]
输出：false
解释：根结点、左子结点和右子结点的值分别是 5 、3 和 1 。
由于 5 不等于 3 + 1 ，因此返回 false 。

我的解法：

class Solution {
    public boolean checkTree(TreeNode root) {
        if (root == null) {
            return false;
        }
        int value = (root.left.val) + (root.right.val);
        if (value == root.val) {
            return true;
        }
        return false;
    }
}

---

二、删除有序数组中的重复项

给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。
将最终结果插入 nums 的前 k 个位置后返回 k 。

示例 1：
输入：nums = [1,1,2]
输出：2, nums = [1,2,_]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

示例 2：
输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

我的解法： 用上 list.

class Solution {
    public int removeDuplicates(int[] nums) {
        // 创建list
        List<Integer> list = new ArrayList<>();
        list.add(nums[0]);
        // 循环将数组元素和 list 内部的元素比较
        for (int i = 1; i < nums.length; i++) {
            // 不存在就存放进去，存在就跳过该元素。
            if (list.contains(nums[i])) {
                continue;
            }else {
                list.add(nums[i]);
            }
        }
        Object[] objects = list.toArray();
        for (int i=0; i<list.size(); i++) {
            // 将 list 内部的元素传入 nums
            nums[i] = (int)objects[i];
        }
        return list.size();
    }
}

发现提交结果太拉跨了，又换了一种思路写： 设置两个结点.

class Solution {
    public int removeDuplicates(int[] nums) {
        // 设置两个下标，一个控制新数组长度，一个去找非重复元素
        int guard = 0;
        int seek = 1;
        // 循环到 seek 遇到 nums 数组末尾
        while (seek < nums.length) {
            // seek每移动一步，将该位置上的元素与guard比较
            if (nums[seek] == nums[guard]) {
                // 相同 seek 继续往后移动
                seek++;
            }else {
                // 不同，seek位置上的元素存入guard后面一位，再将guard和seek后移一位
                nums[guard+1] = nums[seek];
                guard++;
                seek++;
            }
        }
        return guard + 1;
    }
}

优化下好多了…

---

三、合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

示例 2：
输入：l1 = [ ], l2 = [ ]
输出：[ ]

示例 3：
输入：l1 = [ ], l2 = [0]
输出：[0]

我的解法：

第一次尝试使用一个新 list 来存储 l1 和 l2 比较的数据，最后 list 不能转换成 ListNode 链表类型，GG…

第二次使用 ListNode 链表类型来写，结果对比玩 l1 和 l2 的数据，往新 listnode 里面存，报了空指针异常，GG…

看看大佬的思路吧。
使用递归，对比完一次，把较小的链表插入新 ListNode 链表，然后把新链表和较大的链表放入递归。

大佬解法：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
 
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if(list1 == null) return list2;
        if(list2 == null) return list1;
        ListNode res = list1.val < list2.val ? list1 : list2;
        res.next = mergeTwoLists(res.next, list1.val >= list2.val ? list1 : list2);
        return res;
    }
}

---

四、数组中的第K个最大元素（中等题）

给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。
请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

示例 1:
输入: [3,2,1,5,6,4], k = 2
输出: 5

示例 2:
输入: [3,2,3,1,2,4,5,5,6], k = 4
输出: 4

我的解法： 暂时只会写个简单的冒泡…其他的排序算法忘记了
最后超出时间限制了.

class Solution {
    public int findKthLargest(int[] nums, int k) {
        for (int i = 0; i < nums.length - 1; i++) {
            for (int j = 0; j < nums.length - 1 - i; j++) {
                if (nums[j] < nums[j+1]) {
                    int tmp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = tmp;
                }
            }
        }
        return nums[k-1];
    }
}

大佬解法： 直接使用库函数秒杀…
这是投机取巧的做法，日后还得学其它排序来做这个题目。

class Solution {
    public int findKthLargest(int[] nums, int k) {
        Arrays.sort(nums);
        return nums[nums.length - k];
    }
}