【数据结构与算法】双指针思想——首尾双向遍历

• 1.两数之和 II - 输入有序数组
• 2.两数之和
• 3.盛最多水的容器
• 4.平方数之和
• 5.反转字符串中的元音字母
• 6.验证回文字符串2

两数之和2

LeetCode：两数之和 II - 输入有序数组

题目描述：

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

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

示例：

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

思想：

使用双指针，一个指针指向值较小的元素，一个指针指向值较大的元素。指向较小元素的指针从头向尾遍历，指向较大元素的指针从尾向头遍历。

• 如果两个指针指向元素的和 sum == target，那么得到要求的结果；
• 如果 sum > target，移动较大的元素，使 sum 变小一些；
• 如果 sum < target，移动较小的元素，使 sum 变大一些。

代码：

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

两数之和

LeetCode：两数之和

题目描述：

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例：

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

思想：

使用map键值对列表；循环遍历数组，每访问一个元素，将其值和下标存入map中；每次循环访问时，查找map中是否已存在与它和为target的key，若存在则输出此时的 i 和该key对应的value。

代码：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> temp =new HashMap<>();
        int[] res=new int[2];
        for(int i=0;i<nums.length;++i){
            if(temp.containsKey(target-nums[i])){
                res[0]=i;
                res[1]=temp.get(target-nums[i]);
                return res;
            }else{
                temp.put(nums[i],i);
            }
        }
        return res;
    }
}

盛最多水的容器

LeetCode：盛最多水的容器

题目描述：

给定 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

说明：你不能倾斜容器，且 n 的值至少为 2。

示例：

输入: [1,8,6,2,5,4,8,3,7]
输出: 49

思想：

设置两个指针，最左端和最右端，比较两端数值大小，选择较小的值的指针向内移动（面积上限由较小的值决定，所以移动较大的指针得到的新值只可能比之前的值小，没有意义），遍历数组，得到最大面积

代码：

class Solution {
    public int maxArea(int[] height) {
        int low=0,high=height.length-1,res=0,min;
        while(low!=high){
            min=height[low]<height[high]?height[low++]:height[high--];
            res=Math.max(res,min*(high-low+1));
        }
        return res;
    }
}

平方数之和

LeetCode：平方数之和

题目描述：

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

示例：

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

思想：

与两数之和类似。注意使用 (int)Math.sqrt(c) 作为尾指针，这样，时间复杂度为 O(sqrt(c))。

代码：

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

反转字符串中的元音字母

LeetCode：反转字符串中的元音字母

题目描述：

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

示例：

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

思想：

首尾双向遍历没有问题；注意以下两点：

• 使用char[]，最后new String(char[])转化为String返回；如果使用StringBuilder就很麻烦；
• 使用HashSet将所有元音字母存入，查找是否包含该字母，只需要O(1)的时间复杂度。

代码：

class Solution {
    private final static HashSet<Character> set = new HashSet<>(
        Arrays.asList('a','e','i','o','u','A','E','I','O','U'));
    public String reverseVowels(String s) {
        char[] str=s.toCharArray();
        for(int i=0,j=s.length()-1;j>i;){
            if(!set.contains(str[i])){
                ++i;
                continue;
            }
            if(!set.contains(str[j])){
                --j;
                continue;
            }
            char temp = str[i];
            str[i] = str[j];
            str[j] = temp;
            ++i;--j;
        }
        return new String(str);
    }
}

验证回文字符串2

LeetCode：验证回文字符串2

题目描述：

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

示例：

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

思想：

自己想的第一种思路：首尾双向遍历，碰到不相等的，向内移位，记录移位次数，超过两次返回false。这样有一个问题，无法判断是移动low还是移high。

正确做法：首尾双向遍历，碰到不相等的，判断内层是否是回文串（单独写一个函数），因为只允许删除一个字符，最多调用两次函数，时间复杂度不会太高。

代码：

class Solution {
    public boolean validPalindrome(String s) {
        //char[] str = s.toCharArray();
        int low = 0,high = s.length()-1;
        while(high>low){
            if(s.charAt(low)!=s.charAt(high)){
                return isValid(s,low,high-1)||isValid(s,low+1,high);
            }
            low++;
            high--;
        }
        return true;
    }
    private boolean isValid(String s,int low,int high){
        while(high>low){
            if(s.charAt(low)!=s.charAt(high)){
                return false;
            }
            low++;
            high--;
        }
        return true;
    }
}