【LeetCode】数组——左右指针

所谓左右指针，就是两个指针相向而行或者相背而行。体现在数组里的应用如下：

一、二分查找（有三种模式：左闭右开，左开右闭，左闭右闭，推荐采取第一种方式；在刷题时思考如果最后区间只剩下一个数或者两个数，自己的写法是否会陷入死循环，如果某种写法无法跳出死循环，则考虑尝试另一种写法。）

	left和right最初的取值	left和right索引时的偏移	while里的循环条件	mid的取值
左闭右闭	left=0，right=numSize-1	left = mid + 1， right = mid - 1	left <= right	mid = left + (right - left) / 2 或者 mid = left + (right - left + 1) / 2
左闭右开	left=0，right=numSize	left = mid + 1， right = mid	left < right	mid = left + (right - left) / 2
左开右闭	left=-1，right=numSize-1	left = mid， right = mid - 1	left < right	mid = left + (right - left + 1) / 2

704. 二分查找

class Solution {
    public int search(int[] nums, int target) {
        int left = 0, right = nums.length;
        while(left < right){
            int mid = left + (right - left) / 2;
            if(nums[mid] < target){
                left = mid + 1;
            }else if(nums[mid] > target){
                 right = mid;
            } else {
                return mid; // 找到目标值，直接返回下标
            }      
        }
        return -1; // 未找到目标值
    }
}

34. 在排序数组中查找元素的第一个和最后一个位置

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int start = findFirstPosition(nums, target);
        int end = findLastPosition(nums, target);
        return new int[]{start, end};
    }
    
    private int findFirstPosition(int[] nums, int target){
        int left = 0, right = nums.length;
        while(left < right){
            int mid = left + (right - left) / 2;
            if(nums[mid] < target){
                left = mid + 1;
            }else{
                right = mid;
            }
        }
        if(left < nums.length && nums[left] == target){
            return left;
        }else{
            return -1;
        }
    }
    
    private int findLastPosition(int[] nums, int target){
        int left = 0, right = nums.length;
        while(left < right){
            int mid = left + (right - left) / 2;
            if(nums[mid] <= target){
                left = mid + 1;
            }else{
                right = mid;
            }
        }
        if(left > 0 && nums[left-1] == target){
            return left - 1;
        }else{
            return -1;
        }
    }
}

35. 搜索插入位置

class Solution {
    public int searchInsert(int[] nums, int target) {
        int len = nums.length;
        int left = 0;
        int right = len ;
        while(left < right){
            int mid = left + (right - left) / 2;
            if(nums[mid] < target){
                left = mid + 1;
            }else{
                right = mid ;
            }
        }
        return left;
    }
}

二、两数之和

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

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

三、反转数组

344. 反转字符串

class Solution {
    public void reverseString(char[] s) {
    int n = s.length;
    int left = 0;
    int right = n - 1;
    while (left < right) {
        char tmp = s[left];
        s[left] = s[right];
        s[right] = tmp;
        left++;
        right--;
    }
}
}

四、判断回文串

125. 验证回文串

class Solution {
    public boolean isPalindrome(String s) {
        int n = s.length();
        int left = 0, right = n - 1;
        while (left < right) {
            while (left < right && !Character.isLetterOrDigit(s.charAt(left))) {
                ++left;
            }
            while (left < right && !Character.isLetterOrDigit(s.charAt(right))) {
                --right;
            }
            if (left < right) {
                if (Character.toLowerCase(s.charAt(left)) != Character.toLowerCase(s.charAt(right))) {
                    return false;
                }
                ++left;
                --right;
            }
        }
        return true;
    }
}

680. 验证回文串 II

class Solution {
    public boolean validPalindrome(String s) {
        int left = 0;
        int right = s.length() - 1;
        
        while (left < right) {
            if (s.charAt(left) != s.charAt(right)) {
                // 如果遇到不相等的字符，尝试删除左边或右边的一个字符，然后分别判断剩余部分是否是回文
                return isPalindrome(s, left + 1, right) || isPalindrome(s, left, right - 1);
            }
            left++;
            right--;
        }
        
        return true;
    }

     // 判断从 start 到 end 位置的子串是否是回文
    private boolean isPalindrome(String s, int start, int end) {
        while (start < end) {
            if (s.charAt(start) != s.charAt(end)) {
                return false;
            }
            start++;
            end--;
        }
        return true;
    }
}