文章目录
双指针问题：两个指针同向或逆向遍历数组，同向也叫做滑动窗口，逆向常用于搜索（一般针对有序数组）。
167. 两数之和 II – 中等
在有序数组中找到两个值，使得其和为目标值。 要求：常量的空间复杂度。
输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
2 + 7 = 9； 2的位置是1,7的位置是2
/**
// 这里是有序数组，无序数组可以采用 暴力 或 哈希表 解法。
双指针：分别指向第一个元素和最后一个元素，如果大于target --r， 如果小于target --l；
**/
class Solution {
public int[] twoSum(int[] numbers, int target) {
int l = 0, r = numbers.length - 1;
while (l < r) {
int sum = numbers[l] + numbers[r];
if (sum == target) return new int[]{l+1, r+1};
else if (sum > target) --r;
else ++l;
}
return null;
}
}
/**
二分法：对于每个位置i，在区间 [i+1, numbers.length - 1] 内进行二分查找。
**/
class Solution {
public int[] twoSum(int[] numbers, int target) {
for(int i = 0; i < numbers.length; ++i) {
int l = i+1, r = numbers.length - 1;
while(l <= r) {
int mid = l + (r - l)/2;
if (numbers[i] + numbers[mid] == target) return new int[] {i+1, mid+1};
else if (numbers[i] + numbers[mid] < target) l = mid + 1;
else r = mid - 1;
}
}
return null;
}
}
88. 合并两个有序数组 – 简单
归并两个非递减的数组，要求不开辟额外空间。
输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
/**
思路1：nums2加入到nums1中，然后sort()
思路2：双指针遍历。
**/
class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
int last = m+n-1;
--m;
--n;
while (m >= 0 && n>= 0) {
if (nums1[m] >= nums2[n]) {
nums1[last--] = nums1[m];
--m;
} else {
nums1[last--] = nums2[n];
--n;
}
}
while(n >= 0) nums1[last--] = nums2[n--];
}
}
142. 环形链表 II – 中等
给定一个链表头结点head，如果链表中存在循环，返回环路的起点，否则返回null。
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点 -- pos不用管它
/**
思路1：一边遍历，一边用哈希表记录已经遍历的节点，那么如果存在重复就返回
思路2：Floyd 判圈法 (下面给出证明)
**/
public class Solution {
public ListNode detectCycle(ListNode head) {
ListNode fast = head, low = head;
do {
if (fast == null || fast.next == null) return null;
fast = fast.next.next;
low = low.next;
} while (fast != low);
fast = head;
while (fast != low) {
fast = fast.next;
low = low.next;
}
return fast;
}
}
Floyd 判圈法：fast指针一次走两步，slow指针一次走一步，如果存在循环，那么fast与slow会相遇，
此时，将fast指针指向起点，然后fast与slow每次都走一步，那么再次相遇就是环路起点。
1.判断是否有环？
答：就是判断快慢指针是否会相遇，如果存在循环，慢指针和快指针一定会相遇。
2.求循环长度？
答：当快慢指针相遇时，固定一个指针，另一个指针每次走一步，再次相遇即为环长度。
3.求环的开始起点？
答： 设起始点为S，环起始点为A，相遇点为B环长为L，SA=m，AB=n，
假设相遇时slow走过i个节点，则 i = m + n + aL; ①
那么fast走过2i个节点，2i = m + n + bL; ②
由 ② - ① 得： i = (b-a)L => 快慢指针走过的节点数是L的整数倍
所以 m + n = cL => m = cL - n
当两个指针第一次相遇在B时，让fast指针回到S，且此时每次快慢指针每次都往前走一格，
那么当快指针走完m时，慢指针走完cL-n,恰好相遇在A点
76. 最小覆盖子串 – 困难
求字符串s中包含字符串t中全部字符的最小子串，不存在返回""。
输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
经典的滑动窗口题
/**
滑动窗口：
遍历s之前，先统计t的字符。
当 [l,r] 区间内包含了t的全部字符，尝试移动l，并记录可能的最小结果。
**/
class Solution {
public String minWindow(String s, String t) {
Map<Character, Integer> t_map = new HashMap<>();
int t_len = t.length();
for (int i = 0; i < t_len; ++i) {
char cur = t.charAt(i);
t_map.put(cur, t_map.getOrDefault(cur, 0) + 1);
}
int l = 0, len = 0, minLen = Integer.MAX_VALUE;
int min_l = 0, min_r = 0;
for(int r = 0; r < s.length(); ++r) {
char cur = s.charAt(r);
if (t_map.containsKey(cur)) {
if (t_map.get(cur) > 0) ++len;
t_map.put(cur, t_map.get(cur) - 1);
if (len == t_len) {
while(l <= r) {
cur = s.charAt(l);
if (t_map.containsKey(cur)) {
t_map.put(cur, t_map.get(cur) + 1);
// 不能包含全部字符了
if (t_map.get(cur) > 0) {
if ((r - l + 1) < minLen) {
min_l = l; min_r = r;
minLen = min_r - min_l + 1;
}
--len;
++l;
break;
}
}
++l;
}
}
}
}
return minLen == Integer.MAX_VALUE?"":s.substring(min_l, min_r + 1);
}
}
633. 平方数之和 – 中等
判断一个非负整数，是否是两个整数的平方和。
输入：c = 5
输出：true
解释：1 * 1 + 2 * 2 = 5
/**
使用双指针枚举。
**/
class Solution {
public boolean judgeSquareSum(int c) {
int l = 0, r = (int)Math.sqrt(c);
while(l <= r) {
int res = c - l * l;
if (res == r * r) return true;
else if (res > r*r) ++l;
else --r;
}
return false;
}
}
/** 其他思路 **/
class Solution {
public boolean judgeSquareSum(int c) {
for (long a = 0; a * a <= c; a++) {
double b = Math.sqrt(c - a * a);
if (b == (int) b) {
return true;
}
}
return false;
}
}
680. 验证回文串 II – 简单
判断s能否在至多删除一个字符内变成回文串。
输入：s = "abca"
输出：true
解释：你可以删除字符 'c' 。
/**
思路：l，r指向s的左右边界，同时往里走，如果位置的字符不相等，则判断 (l, r-1) (l+1, r) 是否是回文串
**/
class Solution {
public boolean validPalindrome(String s) {
int l = 0, r = s.length() - 1;
while (l <= r) {
if (s.charAt(l) != s.charAt(r)) return validString(s, l, r-1) || validString(s, l+1, r);
++l;
--r;
}
return true;
}
private boolean validString(String s, int l, int r) {
while(l <= r) {
if (s.charAt(l) != s.charAt(r)) return false;
++l;
--r;
}
return true;
}
}
524. 通过删除字母匹配到字典里最长单词 – 中等
找到字典中 长度最长且字母序最小的字符串 ，使得其可以被给定字符串的子序列包含。
输入：s = "abpcplea", dictionary = ["ale","apple","monkey","plea"]
输出："apple"
解释：dictionary中apple是可以被s包含的最长且字母序最小的字符串。
/**
思路：按照长度降序 字母序升序排序，然后找到排序后最先可以被s包含的串。
e1.compareTo(e2) e1在e2之前返回1 相等返回 0 否则返回 -1
**/
class Solution {
public String findLongestWord(String s, List<String> dictionary) {
Collections.sort(dictionary, (e1, e2) -> {
if (e1.length() != e2.length()) return e2.length() - e1.length();
else return e1.compareTo(e2);
});
for (String d : dictionary) {
if(checkEq(d, s)) return d;
}
return "";
}
private boolean checkEq(String d, String s) {
int d_i = d.length() - 1, s_i = s.length() - 1;
while(s_i >= 0) {
if (d_i < 0) return true;
if (d.charAt(d_i) == s.charAt(s_i)) --d_i;
--s_i;
}
return d_i < 0;
}
}
340 至多包含k个不同字符的最长子串 – 困难 (会员题)
/**
思路： 和76类似
**/
class Solution {
public int lengthOfLongestSubstringKDistinct(String s, int k) {
if (k == 0) return 0;
Map<Character, Integer> map = new HashMap<>();
int maxLen = 0, l = 0, cnt = 0;
for (int r = 0; r < s.length(); r++) {
char cur = s.charAt(r);
if (!map.containsKey(cur)) ++cnt;
map.put(cur, map.getOrDefault(cur, 0) + 1);
while (cnt > k) {
cur = s.charAt(l++);
map.put(cur, map.get(cur) - 1);
if (map.get(cur) == 0) {
--cnt;
map.remove(cur);
}
}
maxLen = Math.max(maxLen, r - l + 1);
}
return maxLen;
}
}
扫一扫
876
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
