双指针（java）

1. 基本思想与原理

双指针算法通过维护两个指针（索引或节点引用）在数据结构中协同移动，以优化时间复杂度。其核心在于减少不必要的遍历次数，将原本需要嵌套循环的问题转化为单次遍历，时间复杂度通常从 O(n²) 降低至 O(n) 或 O(n log> n)，适用于数组、链表、字符串等线性结构 。

核心特点：

双指针协同：两指针根据规则同步或异步移动，覆盖问题解空间。
单调性依赖：多数问题需数据结构具备有序性或其他规律，例如排序后的数组或特定约束的子串。
高效性：通过剪枝或跳过无效区间，避免重复计算。

2. 分类与应用场景

2.1 快慢指针

原理：两个指针以不同速度移动，常用于 链表操作 和 循环检测。
应用场景：
链表环检测：快指针每次移动两步，慢指针移动一步，若相遇则存在环 。
链表中点查找：快指针到末尾时，慢指针指向中点 。
删除重复元素：慢指针标记唯一元素位置，快指针遍历数组（如有序数组去重）

2.2 对撞指针（左右指针）

原理：两指针从两端向中间移动，适用于 有序数组查找 或 对称性问题。
应用场景：
两数之和：在排序数组中找和为目标值的两个数（指针调整方向基于当前和与目标值的比较） 。
盛水容器：计算最大容积时，移动高度较小的指针以寻求更大可能 。
反转数组/字符串：交换左右指针元素直至相遇

2.3 滑动窗口

原理：维护动态窗口，通过调整窗口边界寻找最优解，常用于 子串/子数组问题。
应用场景：
最小覆盖子串：窗口覆盖目标字符集时收缩左边界以优化长度 。
最长无重复子串：右指针扩展窗口，左指针在重复时跳跃 。

3.题目练习

题目：

解题思路;
  left指向的值等于val时，用right指向的末尾的值覆盖。

class Solution {
    public int removeElement(int[] nums, int val) {
    //     int n = nums.length;
    //     int left = 0;

    //     for (int right = 0; right < n; right++) {
    //         if(nums[right] != val){
    //             nums[left] = nums[right];
    //             left++;
    //         }
    //     }
    //     return left;
    // }

        int n = nums.length;
        int left = 0, right = n;
        while(left < right) {
            if(nums[left] == val) {
                nums[left] = nums[--right];
            }else {
                left++;
            }
        }
        return left;
    }
}

题目;

解题思路：

1. 在数组中找到介于正数与负数之间的值的位置neg。
2. 在平方后，neg前面的值倒序递增，neg后面的值正序递增，可以left与right初始为neg-1、neg,二者以递减、递增的顺序进行比较，较小者存入结果数组中。
3. 循环结束后，将余下的一边的数按序添加至结果数组中。

class Solution {
    public int[] sortedSquares(int[] nums) {
        int n = nums.length;
        int[] arr = new int[n];
        int neg = 0;

        if(nums[0] >= 0) {
            neg = 0;
        }else if(nums[n-1] <= 0){
            neg = n-1;
        } 
        for(int i = 1; i < n; i++) {
            if(nums[i] >= 0 && nums[i-1] < 0) {
                neg = i;
            }
        }

        int left = neg - 1, right = neg;
        int i = 0;
        for(; left >= 0 && right < n; i++) {
            int numL = nums[left] * nums[left];
            int numR = nums[right] * nums[right];
            if(numL > numR) {
                arr[i] = numR;
                right++;
            }else {
                arr[i] = numL;
                left--;
            }
        }

        while(left >= 0) {
            arr[i++] = nums[left] * nums[left];
            left--;
        }
        while(right < n) {
            arr[i++] = nums[right] * nums[right];
            right++;
        }

        return arr;
    }
}

题目：

解题思路：
  采用滑动窗口，窗口内的值的总和小于target时，右移right添加新值；
大于target时，右移left减去最左边的值，并更新窗口大小。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int n = nums.length;
        if(n == 0) {
            return 0;
        }

        int sum = 0, ans = n+1;
        
        int left = 0, right = 0;
        while (right < n) {
            sum += nums[right];
            
            while(sum >= target) {
                ans = Math.min(ans, right-left+1);
                sum -= nums[left++];
            }
            right++;
        }

        return (ans != n+1) ? ans : 0;
    }
}