LeetCode刷题——巧用双指针

ha_lee

已于 2022-09-14 22:10:10 修改

阅读量516

点赞数

分类专栏：刷题文章标签： leetcode 算法数据结构

于 2022-07-03 13:32:18 首次发布

本文链接：https://blog.csdn.net/ha_lee/article/details/125564721

版权

刷题专栏收录该内容

13 篇文章 0 订阅

订阅专栏

双指针解决思路

双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。也可以延伸到多
个数组的多个指针。
若两个指针指向同一数组，遍历方向相同且不会相交，称滑动窗口。经常用于区间搜索。
若两个指针指向同一数组，但是遍历方向相反，则可以用来进行搜索，待搜索的数组往往是
排好序的。

167. Two Sum II - Input array is sorted (Easy)

问题描述
在一个增序的整数数组里找到两个数，使它们的和为给定值。已知有且只有一对解。

输入输出样例
输入是一个数组（numbers）和一个给定值（target）。输出是两个数的位置，从1 开始计数。

Input: numbers = [2,7,11,15], target = 9
Output: [1,2]

思路
使用头尾指针，如果两个元素之和大于target，尾指针左移；如果两个元素之和小于target，头指针右移，如果相等则找到目标位置。

代码

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int[] addr = new int[2];
        int head = 0,tail = numbers.length-1;
        while(head<tail){
            if(numbers[head]+numbers[tail]>target){
                tail--;
            }else if(numbers[head]+numbers[tail]<target){
                head++;
            }else{
                addr[0]=head+1; 
                addr[1]=tail+1;
                break;
            }
        }
        return addr;
    }
}

88. Merge Sorted Array (Easy)

问题描述
给定两个有序数组，把两个数组合并为一个。

输入输出样例
输入是两个数组和它们分别的长度m 和n。其中第一个数组的长度被延长至m + n，多出的
n 位被0 填补。题目要求把第二个数组归并到第一个数组上，不需要开辟额外空间

Input: nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3 Output:
nums1 = [1,2,2,3,5,6]

思路
将nums1从后往前排将nums1和nums2各自最大的值放入，通过这种方式避免了重新创建一个新的数组放入。

代码

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p = m+n-1; //指向nums1结尾
        m--;
        n--;
        while(m>=0&&n>=0){
            if(nums1[m]>nums2[n]){
                nums1[p]=nums1[m];
                p--;
                m--;
            }else {
                nums1[p]=nums2[n];
                p--;
                n--;
            }
        }
        while (n>=0)nums1[p--]=nums2[n--]; //如果n还没到头，则直接将0-n的值放入已经有序
        //如果是m还没到头，则不用管，因为已经有序放在了nums1前面（如果是创建新的数组放置，则需要考虑）
    }
}

142. Linked List Cycle II (Medium)

题目描述
给定一个链表，如果有环路，找出环路的开始点。

输入输出样例
输入是一个链表，输出是链表的一个节点。如果没有环路，返回一个空指针。
在这里插入图片描述
思路
判断是否有环：快慢指针，如果这两个指针能相遇，则说明有环；如果两个指针指向了null，则说明无环

代码

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast=head;
        ListNode slow=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;
    }
}

76.MinimumWindow Substring (Hard)

题目描述
给定两个字符串S 和T，求S 中包含T 所有字符的最短连续子字符串的长度，同时要求时间复杂度不得超过O(n)。
输入输出样例
输入是两个字符串S 和T，输出是一个S 字符串的子串。

思路
设置一个滑动窗口，窗口指针分别为left和right，right向右移动扩展窗口，如果此时窗口中包含所有目标字符串字符，则left向右逐渐滑动缩小窗口，直到该窗口刚刚好包含全部目标字符。记录当前窗口，left向后再滑动一位，right重复上述操作再次找到新的能包含所有字符的窗口，比较这些找到的窗口，返回最小窗口中的字符串。

代码

class Solution {
    public String minWindow(String s, String t) {
        int[] slidWind = new int[128];//记录滑动窗口中个字符的个数
        int[] need = new int[128];//记录t中各字符的个数

        int start=0;//记录最小窗口的开始位置
        int minLen = s.length()+1;//记录最小窗口的大小
        int left=0,right=0;//窗口的两头

        for (char a : //统计t中各字符的数量
                t.toCharArray()) {
            need[a]++;
        }

        int contains=0; //记录窗口中包含t
        //right向右扩充窗口
        while (right<s.length()){
            if(need[s.charAt(right)]==0){ //当前右端点不在所需字符串中
                right++;
                continue;
            }
            //当前点在所需字符串中
            int a = slidWind[s.charAt(right)];
            int b = need[s.charAt(right)];
            if(slidWind[s.charAt(right)]<need[s.charAt(right)]){
                contains++;//如果right指向的当前字母在t中
            }
            slidWind[s.charAt(right)]++;
            right++;
            while (contains == t.length()){ //窗口中全部包含了t
                //左端点向右滑动
                if(right-left<minLen){
                    minLen = right-left;
                    start = left;
                }
                //开始将窗口左端点向右滑动
                if(need[s.charAt(left)]==0){
                    left++;
                    continue;
                }
                if(slidWind[s.charAt(left)]==need[s.charAt(left)]){
                    contains--;
                }
                slidWind[s.charAt(left)]--;
                left++;
            }
        }
        //如果最小长度还为初始值，说明没有符合条件的子串
        if (minLen == s.length() + 1) {
            return "";
        }
        return s.substring(start,start+minLen);
    }
}

633. Sum of Square Numbers (Easy)

问题说明
给定一个非负整数 c ，你要判断是否存在两个整数 a 和 b，使得 $a^2 + b^2 = c$ 。

输入输出样例
示例 1：

输入：c = 5
输出：true 解释：1 * 1 + 2 * 2 = 5

示例 2：

输入：c = 3
输出：false

思路
双指针，左边指针从0开始，由指针从 $\sqrt c$ 开始，如果 $l e f t * l e f t + r i g h t * r i g h t < 0$ 左指针右移，如果 $l e f t * l e f t + r i g h t * r i g h t > 0$ 右指针左移，相等则返回true。如果遍历完依然没有找到相等，则返回false（注意：平方运算可能会超过int最大长度，需要使用long）

代码

class Solution {
    public boolean judgeSquareSum(int c) {
        long left=0,right=(long)Math.sqrt(c); 
        while (left<=right){
            long sum = left*left+right*right;
            if(sum>c){
                right--;
            }else if(sum<c){
                left++;
            }else return true;
        }
        return  false;
    }
}

680. Valid Palindrome II (Easy)

问题描述
给定一个非空字符串 s，最多删除一个字符。判断是否能成为回文字符串。

示例 1:

输入: s = “aba”
输出: true

示例 2:

输入: s = “abca”
输出: true
解释: 你可以删除c字符。

示例 3:

输入: s = “abc”
输出: false

思路
使用双指针，分别指向数组开始和结尾，然后同时向中间移动，如果每次元素都相等则说明该字符串是回文。该问题为删除一个字符后为回文，如果遇到指针指向的元素不一致，则两个指针分别跳过一个元素再判断是否是回文，如果两个都跳过一次剩下的字符串仍然不是回文，则返回否。
代码

class Solution {
    public boolean validPalindrome(String s) {
        int left=0,right=s.length()-1;
        while (left<=right){
            if(s.charAt(left)==s.charAt(right)){
                left++;
                right--;
            }else{
            	//注意此处，substring区间是左闭右开
                if(isPalindrome(s.substring(left,right)))return true;
                if(isPalindrome(s.substring(left+1,right+1)))return true;
                return false;
            }
        }
        return true;
    }
    
    public boolean isPalindrome(String t){
        int left=0,right=t.length()-1;
        while (left<=right){
            if(t.charAt(left)==t.charAt(right)){
                left++;
                right--;
            }else return false;
        }
        return true;
    }
}

524.Longest Word in Dictionary through Deleting (Medium)

问题描述
给你一个字符串 s 和一个字符串数组 dictionary ，找出并返回 dictionary 中最长的字符串，该字符串可以通过删除 s 中的某些字符得到。
如果答案不止一个，返回长度最长且字母序最小的字符串。如果答案不存在，则返回空字符串。

输入输出样例

示例 1：

输入：s = “abpcplea”, dictionary = [“ale”,“apple”,“monkey”,“plea”]
输出：“apple”

示例 2：

输入：s = “abpcplea”, dictionary = [“a”,“b”,“c”]
输出：“a”

思路
遍历字符串数组，完成两个步骤：1.判断当前字符串是否包含在给定字符串中 2.如果有多个字符串都包含在给定字符串中，根据条件找出最优（长度最长，相等长度情况判断字符串序）
对于步骤1：用两个指针i，j分别指向给定字符串s和数组当前字符串dic的首字符，遍历给定字符串s，如果当前字符相等，则j++。如果j走到末尾，说明s包含dic。
对于步骤2：开始定义一个result，每次把最优的字符赋值给result，最后返回result。

代码

class Solution {
    public String findLongestWord(String s, List<String> dictionary) {
        String result=""; //最终的结果
        for (String dic :dictionary) {
            int i=0;//指向s的首字符
            int j=0;//指向dic的首字符
            while (j<dic.length() && i<s.length()){
                if(dic.charAt(j)==s.charAt(i)){
                    j++;
                }
                i++;
            }
            if(j==dic.length()){ //dic出现在字符串s中
                if(dic.length()>result.length()){
                    result = dic;
                }else if(dic.length()==result.length() && result.compareTo(dic)>0){
                    result = dic;
                }
            }
        }
        return result;
    }
}