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

什么是双指针

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

例题

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

输入：[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各自再执行快速排序，在将左右子序列排好序列后，整个序列就有序了。

[26,53,48,15,13,48,32,15]快排

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); 
 }