算法模版（一）——排序和二分查找

1.快速排序

基于分治的策略。
步骤

1. 确定分界点x：直接取左边界q[l]，取中间q[(l + r) / 2]，取右边界q[r]，取随机
2. 调整区间：使得分界点左侧都小于等于x，右侧都大于等于x（等于x的数字在哪里是无所谓的）
3. 递归：分别递归处理左右两半

其中第二步可以采取如下策略：
分别设置两个指针i,j指向最左侧和最右侧，i,j同时向中间走，i直到遇见大于x的数字时停下，j遇到小于x的数字时停下，此时交换两个指针指向的数字，重复上述步骤，直到两个指针相遇，这就完成了一次分界。然后递归操作。

算法复杂度$O(n\log n)$(注意这里的时间复杂度是平均时间复杂度，最高的时间复杂度是$O(n^2)$，但是一般是达不到的)

算法模板

//输入一个数组，长度不超过100000，要求排序
#include <iostream>

using namespace std;

const int N = 100010;

int n;
int q[N];

void quick_sort(int q[], int l, int r)
{
    if(l >= r) return; //递归出口一定不能忘
    
    int x = q[(l + r) >> 1], i = l - 1, j = r + 1;
    while(i < j)
    {
        do i ++; while(q[i] < x); //遇到大于x的数字会停下来
        do j --; while(q[j] > x); //遇到小于x的数字会停下来
        if(i < j) swap(q[i], q[j]); //如果i，j合法则交换
    }
    
    quick_sort(q, l, j); //递归左半边
    quick_sort(q, j + 1, r); //递归右半边
}

int main()
{
    scanf("%d", &n);
    
    for(int i = 0; i < n; i ++) scanf("%d", &q[i]);
    
    quick_sort(q, 0, n - 1);
    
    for(int i = 0 ; i < n; i++) printf("%d ", q[i]);
    return 0;
}

归并排序

也是基于分治的思想，分别排序左边和右边
步骤

1. 确定分界点mid = (l + r) >> 1
2. 递归排序左侧和右侧
3. 归并——合并为一 $★$

用两个指针分别指向两个区间的左端点，两个指针一起向后，比较两个数字大小，把更大的数字放在前面，同时更大的指针++，直到有一个指针到达区间右端点，最后把剩下的数字接在后面

算法复杂度 $O(n\log n)$

完整代码

#include <iostream>

using namespace std;

const int N = 100010;

int q[N], n, temp[N];

void merge_sort(int q[], int l, int r)
{
    if(l >= r) return;
    
    int mid = (l + r) >> 1;
    merge_sort(q, l, mid);
    merge_sort(q, mid + 1, r);
    
    int k = 0, i = l, j = mid + 1;
    while(i <= mid && j <= r) //这里一定要记得加上等号
    {
        if(q[i] <= q[j]) temp[k ++] = q[i ++];
        else temp[k ++] = q[j ++];
    }
    
    //处理没有遍历完的数组
    while(i <= mid) temp[k ++] = q[i ++];
    while(j <= r) temp[k ++] = q[j ++];
    
    for(i = l, j = 0; i <= r; j ++, i ++) q[i] = temp[j];
    
}
int main()
{
    cin >> n;
    for(int i = 0; i < n; i++) scanf("%d", &q[i]);
    
    merge_sort(q, 0, n-1);
    
    for(int i = 0; i < n; i ++) printf("%d ", q[i]);
    
    return 0;
}

二分查找

原理太简单，直接给模板，复杂度是$n\log n$
整数二分

#include <bits/stdc++.h>

using namespace std;

const int N = 100010;

int n, q;
int a[N];

int main()
{
    cin >> n >> q;

    for(int i = 1; i <= n; i++) scanf("%d", &a[i]);

    while(q --)
    {
        int k;
        cin >> k;
        int l = 1, r = n;
        while(l < r)
        {
            int mid = (l + r) >> 1;
            if(a[mid] >= k) r = mid;
            else l = mid + 1;
        }

        if(a[l] == k)
        {
            int L = l;
            l = 1, r = n ;
            while(l < r)
            {
                int mid = (l + r + 1) >> 1;
                if(a[mid] <= k) l = mid;
                else r = mid - 1;
            }
            int R = r;

            cout << L - 1 << " " <<  R - 1 <<endl;
        }
        else
        {
            cout << "-1 -1"<< endl;
        }

    }

    return 0;
}

顺便附一张图，用不同的符号一定是取决于要的是哪一个值