LeetCode 610, 28, 23

610. 判断三角形

题目链接

610. 判断三角形

表

• 表Triangle的字段为x，y和z。

要求

• 对每三个线段报告它们是否可以形成一个三角形。
• 以 任意顺序 返回结果表。

知识点

1. if：如果满足条件，则返回第二个参数；否则返回第三个参数。
2. 判断三条边能否构成三角形：众所周知，只要三条边满足 任意两边之和大于第三边 ，这三条边就能构成三角形。

思路

本题只需要使用 'if' 判断 x, y, z 是否同时满足 x + y > z、x + z > y、y + z > x 这三个条件，如果满足条件，则返回 'Yes'，否则就返回 'No'。

代码

select
    x,
    y,
    z,
    if(x + y > z and x + z > y and y + z > x, 'Yes', 'No') triangle
from
    Triangle
1
2
3
4
5
6
7

28. 找出字符串中第一个匹配项的下标

题目链接

28. 找出字符串中第一个匹配项的下标

标签

双指针 字符串 字符串匹配

使用 $indexOf()$

思路

在源字符串中找目标字符串的索引可以直接使用 String 对象的 indexOf() 方法，这个方法可以找到源字符串中第一个目标字符串的索引，如果找不到，则返回-1。

代码

class Solution {
    public int strStr(String haystack, String needle) {
        return haystack.indexOf(needle);
    }
}
1
2
3
4
5

双指针

思路

使用两个指针，第一个指针i指向源字符串src，它表示源字符串中以索引i起始的字符串，第二个指针j指向目标字符串tar，它可以表示源字符串中以索引i起始的字符串与目标字符串中的字符相同的个数。

如果发现src[i + j] != tar[j]，那么源字符串中以索引i起始的字符串就不会与tar匹配，此时就得让i向后走一位；否则就表示这个字符匹配成功，此时让j向后走一位，匹配下一个字符。匹配下一个字符前先判断一下：如果j == tar.length - 1，那就说明已经匹配完了，此时源字符串中以索引i起始、以索引i + j结尾的字符串与目标字符串tar完全一致，直接返回i即可。

如果i遍历到超过 源字符串的长度 减去 目标字符串的长度 src.length - tar.length时，则没必要继续匹配，因为源字符串 剩余的字符串长度 小于 目标字符串的长度，连长度都不相等，字符串就更不可能相等了。

例如以下情况：

 src: m o n t h
 tar:   o n e
1
2

某一时刻，i = 1, j = 0，发现src[i + j] = 'o'与tar[j] = 'o'是相等的，然后j++；进入下一次比较，i = 1, j = 1，发现src[i + j] = 'n'与tar[j] = 'n'是相等的，然后j++；进入下一次比较，i = 1, j = 2，发现src[i + j] = 't'与tar[j] = 'e'是不相等的，然后i++，变成下面这样：

 src: m o n t h
 tar:     o n e
1
2

进入下一次比较，i = 2, j = 0，发现src[i + j] = 'n'与tar[j] = 'o'是不相等的，然后i++，变成下面这样：

 src: m o n t h
 tar:       o n e
1
2

此时发现i = 3超过了(src.length = 5) - (tar.length = 3) = 2，不需要再比较了，返回-1。

代码

class Solution {
    public int strStr(String haystack, String needle) {
        char[] src = haystack.toCharArray();
        char[] tar = needle.toCharArray();
        for (int i = 0; i <= src.length - tar.length; i++) {
            for (int j = 0; j < tar.length; j++) {
                if (tar[j] != src[i + j]) {
                    break;
                }
                if (j == tar.length - 1) {
                    return i;
                }
            }
        }
        return -1;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

讲一讲双指针的缺点

这道题的难度是简单，但可以使用很难懂的算法——$KMP$。

对于这两个字符串src = aaaabbbccc, tar = aab，比较过程如下：

src: a a a a b b b c c c
tar: a a b
1
2

src: a a a a b b b c c c
tar:   a a b
1
2

src: a a a a b b b c c c
tar:     a a b
1
2

在使用双指针的解法时，已经有两个a匹配上了，还要在移动i时让j清零，浪费了比较的结果。对这点理解不深是很正常的，学会$KMP$后就理解了，之后我会讲一讲$KMP$的，先留个悬念吧。

23. 合并 K 个升序链表

题目链接

23. 合并 K 个升序链表

标签

链表 分治 堆（优先队列） 归并排序

思路

对于多个而言，都可以想一想是否可以使用分治的思路。

比如本题，可以将 合并k个升序链表的问题 分解为 合并两个链表的问题，使用递归，求出区间的左子区间的升序链表和区间的右子区间的升序链表，然后合并这两个链表，并将结果返回。递归的终止条件是区间的长度为1，这就意味着此时区间内只有一个有序链表，不用合并，直接返回。

代码

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists.length == 0) {
            return null;
        }
        return mergeKLists(lists, 0, lists.length - 1);
    }
    private ListNode mergeKLists(ListNode[] lists, int i, int j) {
        if (i == j) { // 如果区间只剩一个链表
            return lists[i]; // 则直接返回
        }
        int mid = i + j >> 1; // 区间中点
        ListNode left = mergeKLists(lists, i, mid); // 左子区间的有序链表
        ListNode right = mergeKLists(lists, mid + 1, j); // 右子区间的有序链表
        return mergeTwoList(left, right); // 合并左右子区间的有序链表
    }
    private ListNode mergeTwoList(ListNode list1, ListNode list2) {
        ListNode sentinel = new ListNode(-1);
        ListNode curr = sentinel;
        while (list1 != null && list2 != null) {
            if (list1.val < list2.val) {
                curr.next = list1;
                list1 = list1.next;
            } else {
                curr.next = list2;
                list2 = list2.next;
            }
            curr = curr.next;
        }
        if (list1 != null) {
            curr.next = list1;
        } else {
            curr.next = list2;
        }
        return sentinel.next;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37