1.1基础算法 | 快速排序、归并排序、二分法查找

1.1 基础算法(一)

这是我的一个算法网课学习记录，道阻且长，好好努力

---

代码模(母)板，理解，背过；

​ 题目，检验，默写，调试；

​ 提高熟练度，删掉，重新写3-5遍。

1.1.1 快速排序

基本思想：分治(Divide_and_conquer)

1. 确定排序分界点 x (随机)

2. 根据 x 调整个区间

3. 递归处理左右两段

一般的时间复杂度：O(nlogn)（平均的）

一般的空间复杂度：O(logn)

不稳定的：当值相等的时候，次序可能发生变化(使用双关键字可以解决)

#include <iostream>

using namespace std;

const int N = 1e6 + 10;

int n;
int q[N];

void quick_sort(int q[], int l, int r){
    if (l >= r) return;
    
    int x = q[l], i = l - 1, j = r + 1;
    while (i < j){
        do i ++ ; while (q[i] < x);
        do j -- ; while (q[j] > x);
        if (i < j) swap(q[i], q[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.1.2 归并排序

基本思想：分治(Divide_and_conquer)

1. 确定分界点，mid，(1 + r) / 2
2. 递归排序，左边和右边
3. 归并，合二为一

一般的时间复杂度：O(logn)（平均的）

一般的空间复杂度：O(1)

稳定的：当值相等的时候，次序不会发生变化

#include <iostream>

using namespace std;

const int N = 1000010;
 
int n;
int q[N], tmp[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]) tmp[k ++ ] = q[i ++ ];
    	else tmp[k ++ ] = q[j ++ ];
    while(i <= mid) tmp[k ++ ] = q[i ++ ];
    while(j <= r) tmp[k ++ ] = q[j ++ ];
    
    for (i = l, j = 0; i <= r; i ++, j ++ ) q[i] = tmp[j];
    
    return;
}

int main()
{
    scanf("%d", &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;
}

1.1.3 二分查找排序

基本思想：

所谓的二分算法,就是我们知道当前的候选区间中,一定存在我们要找到的答案,而且我们发现这个区间拥有单调性质此类的性质,那么我们可以不停地缩减候选区间的范围,达到排除无用答案的效果.

一般的时间复杂度：O(nlogn)（平均的）

一般的空间复杂度：O(logn)

稳定的：当值相等的时候，次序不会发生变化

• 整数二分

// 区间[l, r]被划分成[l, mid]和[mid + 1, r]时使用：
int bsearch_1(int l, int r)
{
	while (l < r)
    {
        int mid = l + r >> 1;
        if (check(mid)) r = mid;	// check()判断mid是否满足性质
        else l = mid + 1;
    }
    return l;
}

// 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用：
int bsearch_2(int l, int r)
{
    while (l < r)
    {
        int mid = l + r + 1 >> 1; // l = mid; 补上+1
        if (check(mid)) l = mid;
        else r = mid - 1;
    }
    return l;
}

先写一个check()函数，根据该函数判断区间，写出模板

例题 AcWing 789. 数的范围

#include <iostream>

using namespace std;

const int N = 1e6 + 10;

int n, m;
int q[N];

int main()
{
    scanf("%d%d", &n, &m); // n 数组大小; m 要查找的次数
    for (int i = 0; i < n; i ++) scanf("%d", &q[i]);
    
    while (m -- )
    {
    	int x;
        scanf("%d", &x);
        
        int l = 0, r = n - 1;
        while (l < r)
        {
            int mid = l + r >> 1; // 先这样写上，根据check函数的性质看是否需要补1
            if (q[mid] >= x) r = mid; // 注意>=取dneg'hao 
            else l = mid + 1;
        }
        
        if (q[l] != x) cout << "-1 -1" << endl;
       	else
        {
            cout << l << ' ';
            
            int l = 0, r = n - 1;
            while (l < r)
            {
                int mid = l + r + 1 >> 1; // 
                if (q[mid] <= x) l = mid;
                else r = mid - 1;
            }
            
            cout << l << endl;
        }
    }
    
    return 0;
}

• 浮点数二分

当 epsilon <= 10^-6 ，很小了，这个时候可以之间用 l 或者 r 当作我们的答案。

一般不需要控制边界。

经验值：关于精度，epsilon比题目要求保留的小数位数多2

#include <iostream>

using namespace std;

int main()
{
    double x;
    cin >> x;
    
    double l = 0, r = x;
    // 另一种写法：不管三七二十一循环100次
    // for (int i = 0; i < 100; i)
    while(r - l > 1e-8) 
    {
        double mid = (l + r) / 2;
        if (mid * mid > x) r = mid;
        else l = mid;
    }
    
    printf("%lf\n", l);
    
    return 0;
}