leecode-双指针问题
双指针问题
算法解释
-
双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。也可以延伸到多个数组的多个指针。
-
若两个指针指向同一数组，遍历方向相同且不会相交，则也称为滑动窗口（两个指针包围的区域即为当前的窗口），经常用于区间搜索。
-
若两个指针指向同一数组，但是遍历方向相反，则可以用来进行搜索，待搜索的数组往往是排好序的。
两数之和相关问题
167.Sum II - Input array is sorted (Easy)
的整数数组里找到两个数，使它们的和为给定值。已知有且只有一对解
Input: numbers = [2,7,11,15], target = 9
Output: [1,2]
已经知道数组为一个有序数组，分别在首尾处设置指针Lo、hi，不断的计算lo与hi处数值的和，判断是否相等
/**
* 在一个增序的整数数组里找到两个数，使它们的和为给定值。已知有且只有一对解。
* @anthor shkstart
* @create 2020-08-20 20:17
*/
public class Two_Sum {
@Test
public void test1() {
int[] S = {2,3,4};
int target = 6;
System.out.println(Arrays.toString(twoSum1(S,target)));
}
public int[] twoSum(int[] numbers, int target) {
int lo = 0;
int hi = numbers.length - 1;
int sum = 0;
while (lo < hi){
sum = numbers[lo] + numbers[hi];
if (sum == target) break;
if (sum > target){
hi--;
} else{
lo++;
}
}
return new int[]{lo+1,hi+1};
}
/**
* 二分查找
*/
public int[] twoSum1(int[] numbers, int target) {
for (int i = 0; i < numbers.length - 1; ++i) {
int lo = i + 1;
int hi = numbers.length;
int j = find(numbers,target - numbers[i],lo,hi);
if (j != (-1)){
return new int[]{i+1,j+1};
}
}
return new int[]{-1, -1};
}
public int find(int[] S,int e,int lo,int hi){
while (1 < hi - lo){
int mi = (lo + hi) >>1;
//取得两者的中点
if (e < S[mi]){
//mi处值大于e
hi = mi;
//令hi = mi
} else {
//小于e
lo = mi;
//令lo = mi
}
//这里没有考虑相等的情况，把相等放在了右侧区间
}
if(S[lo] == e){
return lo;
} else {
return -1;
}
}
public int find2(int[] S,int e,int lo,int hi){
while (lo < hi){
int n = 0;
while (hi - lo > fib(n) - 1){
//计算合适为恰好的fib(n) - 1 >=
n++;
}
int mi = lo + fib(n-1) - 1;
//前后的子向量的长度为fib(n-1) - 1和fib(n-2) -1
if (e < S[mi]){
hi = mi;
} else if (S[mi] < e){
lo = mi + 1;
} else {
return mi;
}
}
return -1;
}
public int fib(int n){
int f = 0;
//从0开始，
int g = 1;
//斐波那契数列
while(0 < n--){
g = g + f;
//滚动常数
f = g - f;
//先计算后一个数，前一个用相减的方式得到
}
return g;
}
/**
* 指针加上二分查找
*/
public int[] twoSum2(int[] numbers, int target) {
int lo = 0;
int hi = find(numbers,target-numbers[0],0,numbers.length);
int sum = 0;
while (lo < hi){
sum = numbers[lo] + numbers[hi];
if (sum == target) break;
if (sum > target){
hi--;
} else{
lo++;
}
}
return new int[]{lo+1,hi+1};
}
}
平方数之和（简单）167.
题目：给定一个非负整数 c ，你要判断是否存在两个整数 a 和 b，使得 a2 + b2 = c。
一、双指针方法
满足a2+b2 = d2 = c，这是一个中心在原点的圆；在取得a、b时其实关于Y = X是对称的，因此循环的范围可以缩减至根号2分之一；分别在首尾设置指针，判断是否满足条件
/**
* 与之前两数之和类似，不过改成平方
* 时间复杂度O（n）空间复杂度O（1）
* @param c
* @return
*/
public Boolean judgeSquareSum(int c) {
int d = (int) ((Math.sqrt(c)) * Math.sqrt(0.5));
int lo = 0;
int hi = d;
int sum = 0;
while (lo < hi){
sum = lo*lo + hi*hi;
if (sum == c) return true;
if (sum > c){
hi--;
} else{
lo++;
}
}
return false;
}
/**
* 可以尝试二分查找
* i从1到i*i < sum遍历，对每个n =（sum-i*i）进行分析
* 分析方法（a,b,n）
* 每次取中间值，判断其平方是否为n
* 若大于n，则b = 中间值 - 1
* 若小于n,则a = 中间值 + 1
* ==n，则输出true
* 终止于s>e
* 结果时超出了时间限制
*/
public Boolean judgeSquareSum1(int c) {
for (int i = 0;i*i <= c;i++){
int d = c - i*i;
if (find(i,d,d)){
return true;
}
}
return false;
}
public Boolean find(long lo,long hi,int e){
while (1 < hi - lo){
long mi = (lo + hi) >>1;
//取得两者的中点
if (e < mi*mi){
//mi处值大于e
hi = mi;
//令hi = mi
} else {
//小于e
lo = mi;
//令lo = mi
}
//这里没有考虑相等的情况，把相等放在了右侧区间
}
if(lo*lo == e || hi*hi == e){
return true;
} else {
return false;
}
}
/**
* 直接判断存不存在
*/
public Boolean judgeSquareSum2(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;
}
二、费马定理
费马定理：一个非负整数 cc 能够表示为两个整数的平方和，当且仅当 cc 的所有形如4k+34k+3 的质因子的幂次均为偶数；先对数进行因式分解，得到转换为a(n1)+a(n2) + .....然后判断是否含有形为4k + 3 且幂次为奇数的因子
/**
* 费马定理：一个非负整数 cc 能够表示为两个整数的平方和，当且仅当 cc 的所有形如 4k+34k+3 的质因子的幂次均为偶数
*/
public Boolean judgeSquareSum3(int c) {
for (int i = 2; i * i <= c; i++) {
int count = 0;
if (c % i == 0) {
//简单的因式分解
while (c % i == 0) {
count++;
c /= i;
}
/** 到此 c被拆成当前i的n次方 乘 某个无法被当前i整除的数(但是该数进过不断循环总归会变成别的质数的乘积) */
/** 费马平方和定理 */
/** 其他形式的无所谓 只有形为4k + 3 且幂次为奇数的过不了 */
if (i % 4 == 3 && count % 2 != 0)
return false;
}
}
return c % 4 != 3;
}
平方数之和（简单）680.
题目：给定一个非空字符串 s，最多删除一个字符。判断是否能成为回文字符串
一、双指针法
可以把这个题化为数学上的两个蚂蚁在一条轴线上相向运动，在蚂蚁相遇前的见到的每个数字都相等即是。一个回文字符
一旦数字不相等，让两只蚂蚁分别忘掉这个数字，继续前行，当忘掉的次数大于1时，说明这个字符串无法成为一个回文字符串
public Boolean validPalindrome(String s) {
int low = 0, high = s.length() - 1;
while (low < high) {
char c1 = s.charAt(low), c2 = s.charAt(high);
if (c1 == c2) {
low++;
high--;
} else {
Boolean flag1 = true, flag2 = true;
for (int i = low, j = high - 1; i < j; i++, j--) {
char c3 = s.charAt(i), c4 = s.charAt(j);
if (c3 != c4) {
flag1 = false;
break;
}
}
for (int i = low + 1, j = high; i < j; i++, j--) {
char c3 = s.charAt(i), c4 = s.charAt(j);
if (c3 != c4) {
flag2 = false;
break;
}
}
return flag1 || flag2;
}
}
return true;
}
归并两个数组相关问题
合并两个有序数组88.
题目：给定两个有序数组，把两个数组合并为一个。
Input: nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
Output: nums1 = [1,2,2,3,5,6]
一、双指针法
类似于两列蚂蚁排队进洞，其中每一列都按高低排好了，先在要求两队按从低到高依次进洞
两个指针分别指向蚂蚁的两队，比较后将较小的先入洞（即指针向后移动一位），当某一队全部进去后，剩下的蚂蚁高低是有序的直接入洞即可
public int[] merge2(int[] nums1, int m, int[] nums2, int n) {
int t = m-- + n-- - 1;
while (m >= 0 && n >= 0){
nums1[t--] = nums1[m] > nums2[n] ? nums1[m--] : nums2[n--];
}
while (n >= 0){
nums1[t--] = nums2[n--];
}
return nums1;
}
524.通过删除字母匹配到字典里最长单词524.
给定一个字符串和一个字符串字典，找到字典里面最长的字符串，该字符串可以通过删除给定字符串的某些字符来得到。如果答案不止一个，返回长度最长且字典顺序最小的字符串。如果答案不存在，则返回空字符串。
一、双指针法
首先应该将字典中的字符串进行排序，排序的比较方案是：长度长的排前面，当长度相等时字典顺序小的排前面
然后从字典中第一个开始，类似两列蚂蚁，指针分别指向列首，如果相等就向后移动一位，直至任意队列的末尾
不断判断短的一列是否到末尾，若到达就输出true。没有就进行下一个字符串的比较。
public String findLongestWord(String s, List<String> d) {
Collections.sort(d, new Comparator < String > () {
public int compare(String s1, String s2) {
return s2.length() != s1.length() ? s2.length() - s1.length() : s1.compareTo(s2);
}
//这个要多看几遍，还是分不清楚怎么弄
}
);
for (int n = 0;n < d.size();n++) {
String _str = d.get(n);
for (int i = 0,j = 0;i < s.length() && j < _str.length();i++){
if (s.charAt(i) == _str.charAt(j)) j++;
if (j == _str.length()){
return _str;
}
}
}
return "";
}
二、双指针不排序
每次判断时先判断包含与否，再比较长度，时间上可能有点损耗，但空间上不需要额外空间
public Boolean isSubsequence(String x, String y) {
int j = 0;
for (int i = 0; i < y.length() && j < x.length(); i++)
if (x.charAt(j) == y.charAt(i))
j++;
return j == x.length();
}
public String findLongestWord(String s, List < String > d) {
String max_str = "";
for (String str: d) {
if (isSubsequence(str, s)) {
if (str.length() > max_str.length() || (str.length() == max_str.length() && str.compareTo(max_str) < 0))
max_str = str;
}
}
return max_str;
}
快慢指针相关问题
142.环形链表二142.
题目：给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
说明：不允许修改给定的链表
Input: S = "ADOBECODEBANC", T = "ABC"
Output: "BANC"
一、快慢指针法
在数学上，两个点在同一个线路上比赛，如果在线路中有环路的话，跑的快的点最终会追上跑的慢的点，这里便可以判断是否有环路
如果有环路，在两点相遇时，将跑的快的点放回起点，然后两个点以相同的速度运动，再次相遇时的位置就是环路的起点（这里快速每次移动两个单位，慢速每次移动一个单位）
数学上，设直线长度为x，环路长度为y，第一次相遇时，有x+n1y+d = 2(x+d)（1）
将其放回原点后再次移动，相遇时，有x = y - d+n2y（2）
通过化简可知上面两个等式说等价的，即有公式一可得到公式二
public ListNode detectCycle1(ListNode head) {
ListNode slow = head;
ListNode fast = head;
do{
if (fast == null || fast.next == null) return null;
fast = fast.next.next;
slow = slow.next;
}
while (fast != slow);
fast = head;
while (fast != slow){
fast = fast.next;
slow = slow.next;
}
return fast;
}
二、hashset方法
对于数据储存的结构我们知道有collection和map两种体系
collection中的list接口储存有序、可重复的数据,包括Arraylist、linkedlist、vector;set接口，储存无序的不可重复的数据，包括hashset、linkedhashset、treeset。
Map接口用来储存一对（Key-Value）对的数据，有Hashmap、LinkedHashMap、TreeMap、Hashtable、Properties
这里我们选用不可重复的无序的数据储存类型，HashSet，点从原点处开始移动，判断Hashset中是否有相同的数据，没有的话将该点的数据储存进入Hashset中，有的话输出这个节点
public ListNode detectCycle(ListNode head) {
HashSet<ListNode> hashSet = new HashSet<>();
ListNode node = head;
while (node != null){
if (hashSet.contains(node)){
return node;
}
hashSet.add(node);
node = node.next;
}
return null;
}
340.需要会员还没看
滑动窗口相关问题
76覆盖串
给你一个字符串 S、一个字符串 T 。请你设计一种算法，可以在 O(n) 的时间复杂度内，从字符串 S 里面找出：包含 T 所有字符的最小子串。
输入：S = "ADOBECODEBANC", T = "ABC"
输出："BANC"
一、滑动窗口方法
数学上，要在有序集合S中找到集合T中的元素，最好对T中的几个元素进行重点标记，以显示出与众不同，这里选择用向量的方式作标记，因为会有符合要求的多种情况，不要对集合T本身做改变
类似于在一列蚂蚁中找到比较特殊的几种蚂蚁，并要求蚂蚁的距离最短。在队列的头部设置两个指针lo和hi，找到三个元素前hi向后移动，找到三种蚂蚁后，判断并记录距离，然后进行Lo的移动。类似一个滑动的窗口，直到到达队列的尾部为止。
public String minWindow3(String s, String t) {
int[] chars = new int[128];
Boolean[] flag = new Boolean[128];
for (int i = 0;i < t.length();i++){
flag[t.charAt(i)] = true;
++chars[t.charAt(i)];
}
int l = 0;
int cnt = 0;
int _l = 0;
int len = s.length()+1;
//这里+1是灵魂，以免出现a与aa的情况
for (int r = 0;r < s.length();++r) {
if (flag[s.charAt(r)]) {
if (--chars[s.charAt(r)] >= 0) {
++cnt;
}
while (cnt == t.length()) {
if (r - l + 1 < len) {
_l = l;
len = r - l + 1;
}
if (flag[s.charAt(l)] && ++chars[s.charAt(l)] > 0) {
--cnt;
}
++l;
}
}
}
return len > s.length() ? "" : (String) s.substring(_l,_l+len);
}
HashMap的方法
Map<Character, Integer> ori = new HashMap<Character, Integer>();
Map<Character, Integer> cnt = new HashMap<Character, Integer>();
public String minWindow1(String s, String t) {
int tLen = t.length();
for (int i = 0; i < tLen; i++) {
char c = t.charAt(i);
ori.put(c, ori.getOrDefault(c, 0) + 1);
}
int l = 0, r = -1;
int len = Integer.MAX_VALUE, ansL = -1, ansR = -1;
int sLen = s.length();
while (r < sLen) {
++r;
if (r < sLen && ori.containsKey(s.charAt(r))) {
cnt.put(s.charAt(r), cnt.getOrDefault(s.charAt(r), 0) + 1);
}
while (check() && l <= r) {
if (r - l + 1 < len) {
len = r - l + 1;
ansL = l;
ansR = l + len;
}
if (ori.containsKey(s.charAt(l))) {
cnt.put(s.charAt(l), cnt.getOrDefault(s.charAt(l), 0) - 1);
}
++l;
}
}
return ansL == -1 ? "" : s.substring(ansL, ansR);
}
public Boolean check() {
Iterator iter = ori.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry entry = (Map.Entry) iter.next();
Character key = (Character) entry.getKey();
Integer val = (Integer) entry.getValue();
if (cnt.getOrDefault(key, 0) < val) {
return false;
}
}
return true;
}
