acwing-算法基础笔记-基础算法

排序

快排

归并排序

二分

整数二分

浮点二分

放题

快排

我的理解：选取数组中的任一个数作为标准，对一组数据进行分解，然后递归处理。

#include<iostream>

using namespace std;
int q[100010];
void quick_sort(int l,int r)
{
    if(l >= r) return; //此时已经处理好数组的划分。
    int i = l - 1,j = r + 1,x = q[i + j >> 1];
    //i和j作为指针，分别是数组的最左边和最右边，因为是先移动后判断，所以起始化i和j是l - 1,r + 1。
    // i + j >> 1 意思是二级制右移一位，即(i + j)/2。
    while(i < j)//i和j分别向中间移动，若他们遇到不符合while里的条件就会交换对方，确保i的左边都是小于x的数，
    //j的右边都是大于x的数。
    {
        do i ++ ;while(q[i] < x);
        do j -- ;while(q[j] > x);
        if(i < j) swap(q[i],q[j]);
    }
    //递归处理。
    quick_sort(l, j); quick_sort(j + 1, r);
    //最后i应该在j的右边。
}
int main()
{
    int n;
    cin >> n;
    for(int i = 0;i < n;i ++) cin >> q[i];
    quick_sort(0,n - 1);
    for(int i = 0;i < n;i ++) cout << q[i] << " ";
    return 0;
}

归并排序

我的理解：递归排序，重点在于归并。用一个临时数组存放子问题中排好序的数据。

#include<iostream>

using namespace std;
int q[100010],tmp[100010];//tmp数组用来暂时存放排好序的q数组。
void merge_sort(int l,int r)
{
    if(l >= r) return;//一旦任一组数为空即返回。
    int mid = l + r >> 1;//每次将数组一分为二，然后递归排序。
  
    //递归处理。
    merge_sort(l, mid); merge_sort(mid + 1, r);
   
    //归并一分为二的数组。
    int i = l,j = mid + 1,k = 0;
    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 ++];
    
    //因为递归的是q数组，所以要将临时数组物归原主。
    for(int i = l,k = 0;i <= r;i ++,k ++)
    q[i] = tmp[k];
}
int main()
{
    int n; cin >> n;
    for(int i = 0;i < n;i ++) cin >> q[i];
    merge_sort(0, n - 1);
    for(int i = 0;i < n;i ++) cout << q[i] << " ";
    return 0;
}

整数二分

本质就是寻找边界，不是只有单调性才能二分，只要有分明的性质（有边界）就能二分。二分一定能得到数据，但是有可能是近似数据。

如题

代码

#include<iostream>

using namespace std;
int q[100010];
int main()
{
    int m, n, N;
    cin >> m >> n;
    for(int i = 0;i < m;i ++) cin >> q[i];
    while(n --)
    {
        cin >> N;
        int l = 0,r = m - 1,mid;
        
        //找到左边的边界。
        while(l < r)
        {   
            //左边的边界意义：数字大于等于这个边界，之后用递归，锁定范围。
            mid = l + r >> 1;
            if(q[mid] >= N) r = mid;//因为答案在区间[l,mid]中，（mid也可能为边界）。
            else l = mid + 1; //因为答案在右边那部分，且左边边界不能取mid。
        }
        
        //判断是否存在这个数，这里说明二分一定能得出结果，不过可能是近似值。
        if(q[l] != N) printf("-1 -1\n");
        
        //否则一定有在右边的边界，继续同理求出。
        else
        {
            cout << l << ' ';//输出左边界。
            l = 0,r = m - 1;
            //右边的边界意义：数字小于等于这个边界，之后用递归，锁定范围。
            while(l < r)
            {
                mid = l + r + 1 >> 1;//注意这里是l + r + 1，因为边界问题，防止出现死循环。
                if(q[mid] <= N) l = mid;//同理。区间范围缩小为[mid,r]。
                else r = mid - 1;
            }
            cout << l << endl;//每次循环出边界时，l == r，输出r也可。
        }
    }
    return 0;
}

浮点二分

不用考虑边界问题，直接二分。
如题
给定一个浮点数 n，求它的三次方根。

输入格式
共一行，包含一个浮点数 n。

输出格式
共一行，包含一个浮点数，表示问题的解。

注意，结果保留 6 位小数。

数据范围
−10000≤n≤10000
输入样例：
1000.00
输出样例：
10.000000

代码

#include<iostream>

using namespace std;
int main()
{
    double n;
    cin >> n;
    double l = -10000,r = 10000, mid;
    while(r - l >= 1e-8)
    {
        mid = (l + r) / 2;
        if(mid * mid * mid >= n) r = mid;
        else l = mid;
    }
    printf("%lf",l);
    return 0;
}