- 一、判断根结点是否等于子结点之和
- 二、删除有序数组中的重复项
- 三、合并两个有序链表
- 四、数组中的第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];
}
}
