双指针类型题目

1. 633平方数之和 (Easy)

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

使用双指针的思想, 关键在于两个指针的初始化, 左指针取零, 右指针区target的平方根.

class Solution {
    public boolean judgeSquareSum(int c) {
        int num1=0;
        //此处注意, 取值为c的平方根, c过大时,c*c超出int范围,出现负数
        int num2=(int)Math.sqrt(c); 
        int tmp=num1*num1+num2*num2;;
        while(num1<=num2){
            if(c==tmp)
                return true;
            else if(tmp>c)
                num2--;
            else 
                num1++;
            tmp=num1*num1+num2*num2;
        }
        return false;
    }
}

2. 167两数之和Ⅱ - 输入有序数组(Easy)

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

使用双指针的思想, 左指针指向数组第一个元素, 右指针指向末尾元素

• 如果sum==target, 两指针下标即为所求
• 如果sum>target, 左指针右移, 使sum减小
• 如果sum<target, 右指针左移, 使sum增大

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int index1=0;
        int index2=numbers.length-1;
        int tmp=numbers[index1]+numbers[index2];
        while(tmp!=target){
            if(tmp>target)
                index2--;
            if(tmp<target)
                index1++;
            tmp=numbers[index1]+numbers[index2];
        }

        return new int[]{index1+1,index2+1};
    }
}

3. 345反转字符串中的元音字母(Easy)

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

• 示例 :
  ​ 输入: “hello”
  ​ 输出: “holle”

使用双指针, 头指针指向字符串第一个字母, 尾指针指向字符串最后一个字母

• 头指针指向字母不是元音, 将字母添加到数组中, 下标为头指针大小, 头指针后移
• 尾指针指向字母不是元音, 将字母添加到数组中, 下标为尾指针大小, 尾指针前移
• 头尾指针均指向元音字母, 将头指针指向字母添加到数组下标为尾指针大小的位置, 将尾指针指向字母添加到数组下标为头指针大小的位置

class Solution {
    public String reverseVowels(String s) {
        if (s == null)
			return null;

		HashSet<Character> vowels = new HashSet<Character>(
				Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'));

		int i = 0, j = s.length() - 1;
		char[] strArr = new char[s.length()];
		while (i <= j) {
			char lchar = s.charAt(i);
			char rchar = s.charAt(j);

			if (!vowels.contains(lchar)) {
				strArr[i++] = lchar;
			} else if (!vowels.contains(rchar)) {
				strArr[j--] = rchar;
			} else {
				strArr[i++] = rchar;
				strArr[j--] = lchar;
			}
		}
		return new String(strArr);
    }
}

4. 680验证回文字符串Ⅱ(Easy)

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

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

使用双指针, 头尾指针指向字符不相等时, 判断头指针加一和尾指针间的字符串 或 头指针和尾指针减一之间的字符串是否为回文子串即可(相当于删除了一个字符).

Java 中求子串的方法 subtring(begin,end)所求的子串包括begin指向的字符, 不包括end指向字符

class Solution {

    // 判断是否为回文串
	public boolean isPalindrome(String s) {
		for (int i = 0, j = s.length() - 1; i < j; i++, j--) {
			char l = s.charAt(i);
			char r = s.charAt(j);
			if (l != r)
				return false;
		}
		return true;
	}

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

5. 88合并两个有序数组(Easy)

给你两个有序整数数组 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]

由于不能新建数组空间, 关键在于从数组的末尾出发. 选取最大的值向nums1中从后向前逐个存放, 最后若nums2中依然有剩余元素, 将其逐个插入nums1即可

class Solution {
	public void merge(int[] nums1, int m, int[] nums2, int n) {
		int p = m-- + n-- - 1;
		while (m >= 0 && n >= 0) {
			nums1[p--] = nums1[m] > nums2[n] ? nums1[m--] : nums2[n--];
		}
		while (n >= 0) {
			nums1[p--] = nums2[n--];
		}
	}
}

6. 141环形链表(Easy)

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

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

使用快慢指针法, 一个指针一次移动一个节点, 另一个指针一次移动两个节点, 如果有环, 两个指针必然会相遇. 结束条件是 慢指针/快指针/快指针 的下个节点为空

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

7. 524通过删除字母匹配到字典中最长单词(Medium)

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

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

• 输出:
  “apple”

可以使用双指针来判断一个字符串是否为另一个字符串的子序列。为区分出最长字符串, 需要不断比较长度来判断结果是否需要更新. 使用Java 中 String.compareTo(String)<0 来满足字典顺序最小.

class Solution {
    public boolean isSubStr(String s, String target) {
		int i = 0, 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) {
		String longestStr = "";
		int len = 0, tmpLen = 0;
		for (String target : d) {
			len = longestStr.length();
			tmpLen = target.length();
			if (len > tmpLen || (len == tmpLen && longestStr.compareTo(target) < 0)) {
				continue;
			}
			if (isSubStr(s, target)) {
				longestStr = target;
			}
		}
		return longestStr;
	}
}

---

参考：https://github.com/CyC2018/CS-Notes