力扣---指针题

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

1.要求

给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。

函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。

说明:

返回的下标值（index1 和 index2）不是从零开始的。
你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。
示例:

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

2.思路

给定两个指针，一个指针指向值较小的元素，一个指针指向值较大的元素。指向较小元素的指针从头向尾遍历，指向较大元素的指针从尾向头遍历。如果sum为target 达到要求结果，如果大于target,移动较大的元素，如果小于target 移动较小的元素。

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int i=0;
        int j=numbers.length-1;
        while(i<j){
            int sum=numbers[i]+numbers[j];
            if(sum==target){
                return new int []{i+1,j+1};
            }else if(sum<target){
                i++;
            }else{
                j--;
            }
        }
        return null;
        
        
    }
}

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        i=0
        j=len(numbers)-1
        while i<j:
            sum1=numbers[i]+numbers[j];
            if sum1==target:
                return [i+1,j+1]
            elif sum1<target:
                i+=1
            else:
                j-=1
        return null
        

参考：https://github.com/CyC2018/CS-Notes/blob/master/notes/Leetcode%20%E9%A2%98%E8%A7%A3%20-%20%E5%8F%8C%E6%8C%87%E9%92%88.md

633. 平方数之和

1.要求

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

示例1:

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

示例2:

输入: 3
输出: False

2.思路

两个指针一个指向小的元素一个指向大的元素（最大就是本身），如果小于，就使得小的指针，向大移动，大于，就使得大的指针，向小的移动。改进 大的指针的数不可能是target** -2，所以大的指针最多到target**-2.即小于平方根。

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

class Solution:
    def judgeSquareSum(self, c: int) -> bool:
        i=0
        j=math.floor(math.sqrt(c))
        print(j)
        while i<=j:
            sum1=i**2+j**2
            if sum1==c:
                return True
            elif sum1>c:
                j-=1
            else:
                i+=1
        
        return False

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

1.要求

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

示例 1:

输入: “hello”
输出: “holle”
示例 2:

输入: “leetcode”
输出: “leotcede”
说明:
元音字母不包含字母"y"。

2.思路

元音字符 aeiou
双指针法，一个记录小的元音字符，一个记录大的元音字符，然后交换。如果不包含就跳过。

class Solution {
      private final static HashSet<Character> vowels = new HashSet<>(
        Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'));
    public String reverseVowels(String s) {
        int i = 0;
        int j = s.length() - 1;
        char[] result = new char[s.length()];
        while (i <= j) {
            char ci = s.charAt(i);
            char cj = s.charAt(j);
            if (!vowels.contains(ci)) {
                result[i++] = ci;
            } else if (!vowels.contains(cj)) {
                result[j--] = cj;
            } else {
                result[i++] = cj;
                result[j--] = ci;
            }
        }
        return new String(result);

        
    }
}

class Solution:
    def reverseVowels(self, s: str) -> str:
        a1="aeiouAEIOU";
        i=0
        result=list(copy.copy(s))
        
        j=len(s)-1
        while i<=j:
            print(s[i])
            if s[i] not in a1:
                result[i]=s[i]
                i+=1
            elif s[j] not in a1:
                result[j]=s[j]
                j-=1
            else:
                result[i]=s[j]
                result[j]=s[i]
                i+=1
                j-=1
        return "".join(result)
                
        
        

680. 验证回文字符串 Ⅱ

1.要求

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

示例 1:

输入: “aba”
输出: True
示例 2:

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/valid-palindrome-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2.思路

回文串就是从前到后，和从后到前写，都一样，例如‘aba’’ 从后向前也是‘aba’,
双指针问题，一个指向最小，一个指向最大，不断向中间移动，当两个指针指向的字符不同的时候，判断两种情况是否满足，小的增大一个位置看两端的字符是否相同，或者大的位置减小一个是否相同。

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

class Solution:
    def isPalindrom(self,s,i,j):
        return s[i:j+1]==s[i:j+1][::-1]
    
    def validPalindrome(self, s: str) -> bool:
        i=0;
        j=len(s)-1
        while i<j:
            if s[i]!=s[j]:
                return self.isPalindrom(s,i+1,j) or self.isPalindrom(s,i,j-1)
            i+=1
            j-=1
        return True
  
  
        

88. 合并两个有序数组

1.要求

给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。

说明:

初始化 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]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2.思路

1.将数组先放入一个数组中，然后排序（太简单了，效果不是很好）。
2.双指针法，由于num1 已经提供了可以装下两个数组的空间，因此可以直接在上边操作。由于是有序的因此，标记两个数组最大的元素，倒着装填nums1数组。有以下四种情况，1.是num1 数组的指针小于0，就装填另外一个数组，2.反之亦然，3.如果其中num1数组指针的元素小于num2数组指针指向的元素，那么就将num2数组指针指向的元素装填到nums1当前的装填指针位置。

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p1=m-1;
        int p2=n-1;
        
        int p=nums1.length-1;
  

            
        while(p1>=0||p2>=0){
             if(p1<0){
                nums1[p--]=nums2[p2--];
            }else if(p2<0){
                nums1[p--]=nums1[p1--];
            }else if(nums2[p2]<nums1[p1]){
                nums1[p--]=nums1[p1--];
            }else {
                nums1[p--]=nums2[p2--];
            }
        }

        
    }
}

141. 环形链表

1.要求

给定一个链表，判断链表中是否有环。

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

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

2.思路

快慢指针，如果有环，快的终会追上慢的。

public class Solution {
    public boolean hasCycle(ListNode head) {
    if (head == null) {
        return false;
    }
    ListNode l1 = head;
    ListNode  l2 = head.next;
    while (l1 != null && l2 != null && l2.next != null) {
        if (l1 == l2) {
            return true;
        }
        l1 = l1.next;
        l2 = l2.next.next;
    }
    return false;
}
}

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

1.要求

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

示例 1:

输入:
s = “abpcplea”, d = [“ale”,“apple”,“monkey”,“plea”]

输出:
“apple”
示例 2:

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

输出:
“a”
说明:

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

2.思路

1.将所有的可能存储起来然后查找。
2.直接在未排序的字典 d 中查找字符串 target满足 target是 s的子序列。如果 target被找到了，我们将它与其他匹配的字符串做比较，直到找到长度最长、字典序最小的单词为止。

class Solution {
    public boolean isSubtr(String s,String target){
        int i=0;
        int j=0;
        while(i<s.length()&&j<target.length()){
            if(s.charAt(i)==target.charAt(j)){
                j++;
            }
            i++;
        }
        return j==target.length();
    }
    public String findLongestWord(String s, List<String> d) {
        System.out.println(d);
        String longword="";
        for(String target:d){
            int l1=longword.length(),l2=target.length();
            if(l1>l2||(l1==l2&&longword.compareTo(target)<0)){
                //如果参数字符串等于此字符串，则返回值 0；如果此字符串按字典顺序小于字符串参数，则返回一个小于 0 的值；如
                //果此字符串按字典顺序大于字符串参数，则返回一个大于 0 的值。
                continue;
            }
            if(isSubtr(s,target)){
                longword=target;
            }
        }
        return longword;
    }
}