leetcode_双指针

167. 两数之和 II - 输入有序数组

给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。
函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。
说明:
返回的下标值（index1 和 index2）不是从零开始的。
你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。

示例:

输入: numbers = [2, 7, 11, 15], target = 9
输出: [1,2]
解释: 2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。

题解：
1. 暴力，通过

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int[] res = new int[2];
        for (int i = 0; i<numbers.length-1; i++){
            for (int j = i+1; j<numbers.length; j++){
                if (numbers[i] + numbers[j] == target){
                    res[0] = i+1;
                    res[1] = j+1;
                    break;
                }
            }
        }
        return res;
    }
}

时间复杂度O(n^2)
空间复杂度O(1)

2. 双指针
双指针法
一个指针放开头，一个指针放结尾
左边指针向右走两数之和增大，右边指针向左走，两数之和减小。

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int L = 0;
        int R = numbers.length-1;
        int[] res = new int[2];
        while(L<R){
            int sum = numbers[L] + numbers[R];
            if (sum == target){
                res[0] = L+1;
                res[1] = R+1;
                break;
            }
            else if (sum < target){
                L++;
            }
            else{
                R--;
            }
        }
        return res;
    }
}

时间复杂度O(n)
空间复杂度O(1)

---

633. 平方数之和

给定一个非负整数 c ，你要判断是否存在两个整数 a 和 b，使得 a2 + b2 = c。

示例1:

输入: 5
输出: True
解释: 1 * 1 + 2 * 2 = 5

示例2:

输入: 3
输出: False

题解：
a 和 b的范围必在 0~$\sqrt{c}$
可用双指针法。
初始时a为0，b为 int($\sqrt{c}$)
令sum = a*a+b*b

当sum 当sum

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

时间复杂度$O(\sqrt{c})$
空间复杂度O(1)

---

345. 反转字符串中的元音字母

编写一个函数，以字符串作为输入，反转该字符串中的元音字母。

示例 1:

输入: "hello"
输出: "holle"

示例 2:

输入: "leetcode"
输出: "leotcede"

说明:
元音字母不包含字母"y"。

题解：
1. 双指针
L初始指向头，R初始指向尾。

• L向右走直到指向元音字母，
• R向左走直到找到元音字母
• L和R所指元音字母互换

class Solution:
    def reverseVowels(self, s: str) -> str:
        vowel = 'aeiouAEIOU'
        L = 0
        R = len(s)-1
        while L < R:
            while vowel.find(s[L]) != -1 and L < R:
                if vowel.find(s[R]) != -1:
                    temp = s[L]
                    # print(s[:L], s[R], s[L+1:R], s[L], s[R + 1:])
                    s = s[:L] + s[R] + s[L+1:R] + s[L] + s[R + 1:]
                    R -= 1
                    break
                R -= 1
            
            L += 1
        return s

时间复杂度O(n)
空间复杂度O(1)

2. 双指针2
从头到尾遍历字符串，用k表示当前字符。

j初始时指向字符串尾，用于从后往前找元音字母

1. 当k为元音字母时，j从后往前，直到找到元音字母，将该元音字母加入结果中。
2. 当k不是元音字母时，直接将当前字母加入结果中。

class Solution:
    def reverseVowels(self, s: str) -> str:
        vowel = {'a','e','i','o','u','A','E','I','O','U'}
        res=[]
        j=len(s)-1
        for i, k in enumerate(s):
            if k in vowel:
                while s[j] not in vowel:
                    j -= 1
                res.append(s[j])
                j -= 1
            else:
                res.append(k)
        return ''.join(res)

时间复杂度O(n)
空间复杂度O(1)

---

680. 验证回文字符串 Ⅱ

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

示例 1:

输入: "aba"
输出: True

示例 2:

输入: "abca"
输出: True
解释: 你可以删除c字符。

注意:
字符串只包含从 a-z 的小写字母。字符串的最大长度是50000。

题解：
回文串是中心对称的，因此可以用两个指针指向s的头和尾，左指针left每次右移移步，右指针right左移一步，每次看两个指针指向的字符是否相等。
若不相等，由于可以删去一个字符，所以可以判断删去left和right其中一个字符之后的部分是否为回文串。即判断 s[left+1: right] 和s[left, right-1]其中一个是否是回文串。

class Solution{
    public boolean validPalindrome(String s){
        int i = 0;
        int j = s.length()-1;
        for (; i<j; i++, j--){
             if (s.charAt(i) != s.charAt(j)){
                 return isPalindrome(s, i+1, j) || isPalindrome(s, i, j-1);
             }
        }
        return true;
    }
    public boolean isPalindrome(String s, int i, int j){
        for (; i<j;i++, j--){
            if (s.charAt(i) != s.charAt(j)){
                return false;
            }
        }
        return true;
    }
}

时间复杂度O(n)
空间复杂度O(1)

---

88. 合并两个有序数组

给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。
说明:

初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。
你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。

示例:

输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6],       n = 3

输出: [1,2,2,3,5,6]

题解
为避免num1中元素发生覆盖，从尾开始遍历。

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int i = m-1;
        int j = n-1;
        int k = nums1.length-1;
        while (i>=0 && j>=0){
            if (nums2[j] >= nums1[i]){
                nums1[k--] = nums2[j--];
            }
            else{
                nums1[k--] = nums1[i--];
            }
        }
        while (i>=0){
            nums1[k--] = nums1[i--];
        }
        while (j>=0){
            nums1[k--] = nums2[j--];
        }
    }
}

时间复杂度O(m+n)
空间复杂度O(1)

---

141. 环形链表

给定一个链表，判断链表中是否有环。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

题解：双指针法

public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null || head.next == null){
            return false;
        } 
        ListNode fast = head.next;
        ListNode slow = head;
        while (fast!=slow){
            if (fast != null && fast.next!=null){
                fast = fast.next.next;
                slow = slow.next;
            }
            else{
                return false;
            }
        }
        return true;
    }
}

时间复杂度O(n)
空间复杂度O(1)

---

524. 通过删除字母匹配到字典里最长单词

给定一个字符串和一个字符串字典，找到字典里面最长的字符串，该字符串可以通过删除给定字符串的某些字符来得到。如果答案不止一个，返回长度最长且字典顺序最小的字符串。如果答案不存在，则返回空字符串。

示例 1:

输入:
s = "abpcplea", d = ["ale","apple","monkey","plea"]
输出: 
"apple"

示例 2:

输入:
s = "abpcplea", d = ["a","b","c"]

输出: 
"a"

说明:

所有输入的字符串只包含小写字母。
字典的大小不会超过 1000。
所有输入的字符串长度不会超过 1000。

题解：
每个单词和s进行删除字符的匹配，记录匹配且长度最长，字典序最小的单词。
可删除s中某些字符单词的匹配方法：指针法

• j指向单词下标，k指向s下标，初始都为0
• 当j和k所指字符不相同时，需要在 s中找到与j所指相同的单词。k向右移跳过和j所指不相同的字符。同时j向右移一位。
• 当j和k所指字符相同时， j,k同时右移。
• 循环上述过程遍历完其中一个字符串。

比较字典序：str1.compareTo(str2)， 结果小于0时，str1的字典序比str2小。

小 tips: 不用每个单词都进行匹配。
假如当前单词长度比已匹配的单词的长度短，或者一样长但字典序更大就直接跳过这个单词的匹配。

class Solution {
    public String findLongestWord(String s, List<String> d) {
        int max_len = 0;
        int index = -1;
        for (int i = 0; i<d.size(); i++){
            String word = d.get(i);
            int len = word.length();
            // 首先判断当前单词长度是否比已匹配过的单词长，一样长时，看字典序是否更小。
            if (len > max_len || (len==max_len && word.compareTo(d.get(index))<0)){
                // 判断当前单词与s是否匹配
                int j = 0;
                for (int k = 0; j < len && k < s.length(); k++){
                    if (word.charAt(j) == s.charAt(k)){
                        j++;
                    }
                }
                if (j == len){   // 若匹配
                    max_len = len;  // 记录最长长度
                    index = i;      // 记录最长单词在数组中的下标
                }
            }
        }
        
        if (index == -1){
            return "";
        }
        return d.get(index);
    }
}

时间复杂度O(x*n), x表示单词平均长度
空间复杂度O(1)

---