双指针算法

• 一般的双指针算法

  • 单调性问题

case1:

#include<iostream>
using namespace std;
const int N = 100010;
int arr[N], brr[N];

int main()
{
    int n, m, x;
    scanf("%d%d%d", &n ,&m, &x);
    for(int i = 0; i < n; ++i) scanf("%d", &arr[i]);
    for(int i = 0; i < m; ++i) scanf("%d", &brr[i]);
    int i = 0, j = m - 1;
    /*while(i < n || j < m)
    {
        int res = arr[i] + brr[j];              // 虽然res是单调递增的，不过还是有漏洞
        while(i == n - 1) if(res != x) j++;
        while(j == m - 1) if(res != x) i++;
        if(res != x)
        {
            if(arr[i + 1] - arr[i] > (brr[j + 1] - brr[j]) ) j++;
            else i++;
        }
        else break;
    }*/
    
    // 寻找单调性：def: j为每次i往后枚举时,arr[i] + brr[j] > x, j的最小值
    // 则每次i往后枚举时,j必然单调向前移动
    for(; i < n ; ++i)                // for (int i = 0; i < n; ++i)    第12行定义了i,局部变量重复定义
    {
        /*int res = arr[i] + brr[j];*/    // 不能贪图简便就用这个,造成刻舟求剑的错误(此i非彼i,此j非彼j)
        while(j >= 0 && arr[i] + brr[j] > x) j--;
        if(arr[i] + brr[j] == x) break;
    }
    printf("%d %d", i, j);
}

case2:

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int len = gas.size();
        for (int st = 0; st < len;)     // 从 index = 0 开始遍历
        {
            int petro = 0;         // 初始汽油为0
            for (int distance = 0; distance < len; ++distance)   // 每一次出发最多能走多远
            {
                int index = (st + distance) % len;           // 最终走到哪个位置了
                petro += gas[index] - cost[index];
                if (petro < 0)
                {
                   /*st = index + 1;*/     // 这样搞死循环了
                    st = st + distance + 1;
                    break;
                }
                else if (distance == len - 1) return st;     // 还剩下油并且走完了全程
            }
        }
        return -1;
    }
};

• 快慢指针

• 双指针在排序中的应用

  • 01 快排(左右对撞指针、快慢指针)

// 01左右对撞指针(一) Hoare's版本: 小堆、大堆(之间用一条虚拟的分隔线隔开)
void qk_sort(int arr[], int l, int r)    //这里的l, r都是下标
{
	if (l >= r) return;            // 一个元素不用排序
	/*int i = l - 1, j = r + 1;*/        // 为了之后do ...while做准备
	
	int i = l - 1, j = r + 1, ele = arr[r + l >> 1];
	while (i < j)                          // 这里的意思是 i>=j 时,就要退出  若i ==j 则有 arr[<i==j] <= ele ...1
	{                                                                    // arr[i==j>] >=ele  ...2
		do i++; while (arr[i] < ele);                                  //  1 + 2 ==>arr[i==j]==ele 
		do j--; while (ele < arr[j]);
		if (i < j) swap(arr[i], arr[j]);
	}
	qk_sort(arr, l, j );        // arr[<=j] <= ele
	qk_sort(arr, j + 1, r);     // arr[j]之后的,即arr[>j] >= ele
}

// 01左右对撞指针(二) Lomuto’s版本: 小堆、privot、大堆
int partition(int arr[MAXSIZE], int low, int high)
{
	int i = low, j = high;
	int temp = arr[i];
	while (i < j)
	{
		// scanning form right to left!!!
		while (i < j && arr[j] > temp) j--;
		if (i < j)
		{
			arr[i] = arr[j];
			i++;
		}                                 // 如果是 <= 的话,当存在大量重复元素的话,仍然没有改进
		while (i < j && /*a[i] <= temp*/arr[i] < temp) i++;  // 在所以元素重复的情况下,可以达到O(n*log n)
		if (i < j)                              // 此排序算法不稳定
		{
			arr[j] = arr[i];
			j--;
		}
	}
	arr[i] = temp;
	return i;
}
void quickSort(int arr[MAXSIZE], int low,int high)
{
	if (low < high)
	{
		int i = partition(arr, low, high);
		quickSort(arr, low, i - 1);
		quickSort(arr, i + 1, high);
	}
	
}
// 02 快慢指针
int partition(int* arr, int low, int high)    // [low,high)
{
	int pivot = arr[low];
	int mid = low;       // 慢指针
	for (int k = low + 1; k < high; ++k)   // L R U(unsorted)
	{                                     // k 为快指针
		if (arr[k] <= pivot)
		{
			swap(arr[++mid], arr[k]);
		}// 此处省略else分支,一并 并入到++k当中
	}
	swap(arr[low], arr[mid]);
	return mid;
}
void quick_sort(int* arr, int low, int high)     // 语义定义为[low,high)
{
	if (high - low < 2) return;
	int mid = partition(arr, low, high);
	quick_sort(arr, low, mid);
	quick_sort(arr, mid + 1, high);
}

• 02 归排(两个指针分别指向两个序列)

#include<iostream>
using namespace std;
const int N = 1010;
int arr[N];
void merge(int arr[], int begin, int mid, int end) {
    int left_copy[N];
    for (int i = 0, j = begin; j <= mid;) {    //[begin,mid]拷贝
        left_copy[i++] = arr[j++];
    }
    // 双路指针归并
    int i = 0, k = begin, j = mid + 1;
    while (i <= mid && j <= end) {
        if (left_copy[i] > arr[j]) arr[k++] = arr[j++];
        /*else arr[k++] = arr[i++];*/
        else arr[k++] = left_copy[i++];
    }
    // i > mid && j <= end 这种情况不用考虑(本来后半部分就是就地算法)
    while (i <= mid) arr[k++] = left_copy[i++];
}
void merge_sort(int arr[], int begin, int end)      // [begin,end]
{
    if (begin >= end) return;    // 一个元素不用排序
    int mid = (begin + end) / 2;
    merge_sort(arr, begin, mid);
    merge_sort(arr, mid + 1, end);
    merge(arr, begin, mid, end);
}