算法复习-双指针入门，原理与进阶

最新推荐文章于 2025-05-10 18:09:08 发布

韵锦OvO

最新推荐文章于 2025-05-10 18:09:08 发布

阅读量476

点赞数 8

文章标签：算法 java 数据结构

本文链接：https://blog.youkuaiyun.com/m0_73550910/article/details/136780144

版权

本文介绍了双指针技术，包括快慢双指针在删除数组中重复元素的应用以及对撞双指针在快速排序中的使用，展示了如何通过这两个技巧优化查找和排序过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

什么是双指针

双指针指的是两个变量，不一定真的是指针。

例题

删除序列中重复的元素（快慢双指针，对撞双指针）

输入：[1,2,2,2,3,3,5,5,7,8]
输出：[1,2,3,5,7,8]

public static int removeDuplicates(int []nums){
    //slow表示可以放入新元素的位置
    int slow = 1;
    //双指针
    for( int fast= 0; fast < nums.length; fast++){
    if(nums[fast] != nums[slow - 1]){
        nums[slow] = nums[fast];
        slow ++;
        }
    }
return slow;
}

首先定义两个指针slow，fast, slow表示当前位置之前的元素都是重复的，而fast则一直向后找，直到找到与slow位置不一样的，找到之后就将slow向后移动一个位置。

对撞双指针：核心思想是从右侧找到不是val的值来顶替左侧是val的值

应用：快速排序

快速排序是将分治法运用到排序问题的经典例子，快速排序的基本思想是：通过一个标记pivot元素将n个元素的序列划分为左右两个子序列left和right，其中left元素都比pivot小，right的都比pivot的大，然后再次对left和right各自再执行快速排序，在将左右子序列排好序列后，整个序列就有序了。

public static void quickSort(int [] arr, int left, int right){
        if(left < right){
            int pivot = arr[right];
            int i = left - 1;
            for (int j = left; j<right ;j++){
                if(arr[j] < pivot){
                    i++; 
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
            //哨兵移动到pivotIndex上
            int pivotIndex = i+1;
            int temp = arr[pivotIndex];
            arr[pivotIndex] = arr[right];
            arr[right] = temp;

            quickSort(arr, left, pivotIndex - 1);
            quickSort(arr, pivotIndex + 1, right);
        }
    }

void quickSort(int[] array, int start, int end) {
             if (start >= end) {
                 return;
             }
     //这里就是一个对撞的双指针操作
             int left = start, right = end;
             int pivot = array[(start + end) / 2];
 
             while (left <= right) {
                 while (left <= right && array[left] < pivot) {
                     left++;
                 }
             while (left <= right && array[right] > pivot) {
                 right--;
             }
             if (left <= right) {
                 int temp = array[left];
                 array[left] = array[right];
                 array[right] = temp;
                 left++;
                 right--;
              }
             }
 //先处理元素再分别递归处理两侧分支，与二叉树的前序遍历非常像
              quickSort(array, start, right);
              quickSort(array, left, end); 
 }