算法基础复盘笔记Day01【算法基础】—— 快速排序、归并排序、二分、高精度

Java技术一点通

已于 2023-03-15 12:12:36 修改

阅读量945

点赞数 2

分类专栏：数据结构与算法文章标签：快速排序归并排序二分高精度

于 2023-03-10 09:38:18 首次发布

本文链接：https://blog.csdn.net/m0_52691962/article/details/128308374

版权

数据结构与算法专栏收录该内容

12 篇文章 4 订阅

订阅专栏

❤ 作者主页：欢迎来到我的技术博客😎
❀ 个人介绍：大家好，本人热衷于Java后端开发，欢迎来交流学习哦！(￣▽￣)~*
🍊 如果文章对您有帮助，记得关注、点赞、收藏、评论⭐️⭐️⭐️
📣 您的支持将是我创作的动力，让我们一起加油进步吧！！！🎉🎉

第一章快速排序

一、快速排序

1. 题目描述

给定你一个长度为 $n$ 的整数数列。

请你使用快速排序对这个数列按照从小到大进行排序。

并将排好序的数列按顺序输出。

输入格式

输入共两行，第一行包含整数 $n$ 。

第二行包含 $n$ 个整数（所有整数均在 $1∼10^9$ 范围内），表示整个数列。

输出格式

输出共一行，包含 $n$ 个整数，表示排好序的数列。

数据范围

$1 \leq n \leq 100000$

输入样例：

5
3 1 2 4 5

输出样例：

1 2 3 4 5

2. 思路分析

首先设定一个分界值，将数组分为左右两部分。
将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于或等于分界值。
左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

注意： 快速排序算法划分的边界处理很麻烦，可以直接背下算法模板。

3. 代码实现

#include <bits/stdc++.h>

using namespace std;

const int N = 100010;

int q[N];

void quick_sort(int q[], int l, int r)
{
	// 当前数组为空或者只有一个数，直接退出
    if (l >= r) return;
    
    //设置分界点，将数组分为左右两部分
    int i = l - 1, j = r + 1, x = q[l + 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()
{
    int n;
    cin >> n;
    
    for (int i = 0; i < n; i ++ ) cin >> q[i];
    
    quick_sort(q, 0, n - 1);
    
    for (int i = 0; i < n; i ++ ) printf("%d ", q[i]);
    
    return 0;
}

二、第k个数

1. 题目描述

给定一个长度为 $n$ 的整数数列，以及一个整数 $k$ ，请用快速选择算法求出数列从小到大排序后的第 $k$ 个数。

输入格式

第一行包含两个整数 $n$ 和 $k$ 。

第二行包含 $n$ 个整数（所有整数均在 $1∼10^9$ 范围内），表示整数数列。

输出格式

输出一个整数，表示数列的第 $k$ 小数。

数据范围

$1 \leq n \leq 100000$ ,
$1 \leq k \leq n$

输入样例：

5 3
2 4 1 5 3

输出样例：

2. 思路分析

本题要求用快速排序算法求解。

选分界点划分左右数组。
当左边数组个数 < k ，即第 $k$ 个数在左区间，此时递归左区间找第 $k$ 个数即可。
当左边数组个数 > k ，即第 $k$ 个数在右区间，此时递归右区间找第 $k$ 个数即可。
最后数组只剩下一个数，即为第 $k$ 个数。

3. 代码实现

#include <bits/stdc++.h>

using namespace std;

const int N = 100010;

int q[N];

int quick_sort(int q[], int l, int r, int k)
{
    //数组只剩一个数，即为要找的第k个数
    if (l >= r) return q[l];
    
    //选分界线，划分数组
    int i = l - 1, j = r + 1, x = q[l + 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]);
    }
    
    // 左数组的长度：分界点 - 左边界 + 1
    // 如果k在左边界，递归左数组
    if (j - l + 1 >= k) return quick_sort(q, l, j, k);
    // 如果k在右边界，递归右数组
    else return quick_sort(q, j + 1, r, k - (j - l + 1));
}

int main()
{
    int n, k;
    cin >> n >> k;
    
    for (int i = 0; i < n; i ++ ) cin >> q[i];
    
    cout << quick_sort(q, 0, n - 1, k) << endl;
    
    return 0;
}

第二章归并排序

一、归并排序

1. 题目描述

给定你一个长度为 $n$ 的整数数列。

请你使用归并排序对这个数列按照从小到大进行排序。

并将排好序的数列按顺序输出。

输入格式

输入共两行，第一行包含整数 $n$ 。

第二行包含 $n$ 个整数（所有整数均在 $1∼10^9$ 范围内），表示整个数列。

输出格式

输出共一行，包含 $n$ 个整数，表示排好序的数列。

数据范围

$1 \leq n \leq 100000$

输入样例：

5
3 1 2 4 5

输出样例：

1 2 3 4 5

2. 思路分析

确定分界点，取区间中间
递归排序左数组、右数组
合并，将左右两个有序的数组合并成一个有序的数组（二路归并）

3. 代码实现

#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10;

int a[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;
    //每次把较小的值放到tmp中去
    while(i <= mid &&  j <= r) 
        if (q[i]  <= q[j]) tmp[k  ++] = q[i ++];
        else tmp[k ++] = q[j ++];
        
    //判断左边是否访问完，没有的话将剩下的直接插到tmp后面
    while(i <= mid) tmp[k ++] = q[i ++];
    //判断右边是否访问完，没有的话将剩下的直接插到tmp后面
    while(j <= r) tmp[k ++]  = q[j ++];
    
    //再将临时数组tmp复制到原数组q中
    for (int i = l, j = 0; i <= r; i ++, j ++) q[i] = tmp[j];
    
}

int main()
{
    int n;
    cin >> n;
    for (int i = 0; i < n; i ++ ) cin >> a[i];
    
    merge_sort(a, 0, n -1);
    
    for (int i = 0; i < n; i ++)  printf("%d ", a[i]);
    
    return 0; 
}

二、逆序对的数量

1. 题目描述

给定一个长度为 $n$ 的整数数列，请你计算数列中的逆序对的数量。

逆序对的定义如下：对于数列的第 $i$ 个和第 $j$ 个元素，如果满足 $i < j$ 且 $a [i] > a [j]$ ，则其为一个逆序对；否则不是。

输入格式

第一行包含整数 $n$ ，表示数列的长度。

第二行包含 $n$ 个整数，表示整个数列。

输出格式

输出一个整数，表示逆序对的个数。

数据范围

$1 \leq n \leq 100000$
数列中的元素的取值范围 [1, $10^9$ ]。

输入样例：

6
2 3 4 5 6 1

输出样例：

2. 思路分析

我们将序列从中间分开，将逆序对分成三类：

两个元素都在左边；
两个元素都在右边；
两个元素一个在左边，一个在右边；

算法流程：

递归算左边的逆序对数量；
递归算右边的逆序对数量；
算一个元素在左边一个在右边的逆序对数量；
将以上三种情况相加即为总的逆序对数量。

我们可以注意到一个很重要的性质，左右半边的元素在各自任意调换顺序，是不影响第三步计数的，因此我们可以数完就给它排序。这么做的好处在于，如果序列是有序的，会让第三步计数很容易。
如果无序暴力数的话这一步是 $O(n^2)$ 的。

比如序列是这样的：

4 5 6 | 1 2 3

当你发现 4 比 3 大的时候，也就是说右边最大的元素都小于左边最小的元素，那么左边剩下的5和6都必然比右边的所有元素大，因此就可以不用数5和6的情形了，直接分别加上右半边的元素个数就可以了，这一步就降低到了 $O (n)$ 。

因此很自然想到使用归并排序来求解逆序对的数量。

3. 代码实现

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;

const int N = 1e5 + 10;

int a[N], tmp[N];

LL merge_sort(int q[], int l, int r)
{
    if (l >= r) return 0;
    
    int mid = l + r >> 1;
    
    //递归排序左右数组，并且分别加上左右数组中逆序对的数量
    LL res = 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 ++ ] = a[i ++ ];
        else 
        {
            //加上左数组的个数，即为元素一个在左边一个在右边的逆序对数量
            res += mid - i + 1;
            tmp[k ++ ] = a[j ++ ];
        }
    
    //判断左边是否访问完，没有的话将剩下的直接插到tmp后面
    while(i <= mid) tmp[k ++] = a[i ++];
    //判断右边是否访问完，没有的话将剩下的直接插到tmp后面
    while(j <= r) tmp[k ++]  = a[j ++];
    
    //再将临时数组tmp复制到原数组a中
    for (int i = l, j = 0; i <= r; i ++, j ++) a[i] = tmp[j];
    
    return res;
}

int main()
{
    int n;
    cin >> n;
    for (int i = 0; i < n; i ++ ) cin >> a[i];
    
    cout << merge_sort(a, 0, n - 1) << endl;
    
    return 0;
}

第三章二分

一、数的范围

1. 题目描述

给定一个按照升序排列的长度为 $n$ 的整数数组，以及 $q$ 个查询。

对于每个查询，返回一个元素 $k$ 的起始位置和终止位置（位置从 0 开始计数）。

如果数组中不存在该元素，则返回 -1 -1。

输入格式

第一行包含整数 $n$ 和 $q$ ，表示数组长度和询问个数。

第二行包含 $n$ 个整数（均在 $1 \sim 10000$ 范围内），表示完整数组。

接下来 $q$ 行，每行包含一个整数 $k$ ，表示一个询问元素。

输出格式

共 $q$ 行，每行包含两个整数，表示所求元素的起始位置和终止位置。

如果数组中不存在该元素，则返回 -1 -1。

数据范围

$1 \leq n \leq 100000$
$1 \leq q \leq 10000$
$1 \leq k \leq 10000$

输入样例：

6 3
1 2 2 3 3 4
3
4
5

输出样例：

3 4
5 5
-1 -1

2. 思路分析

整数二分算法模板：

bool check(int x) {/* ... */} // 检查x是否满足某种性质

//模模一：尽量往左找目标
// 区间[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;
        if (check(mid)) l = mid;
        else r = mid - 1;
    }
    return l;
}

注意： 模板二中mid需要加上1，因为mid得到的是下取整的数，如果mid不加上1那么有可能[mid, r]更新之后mid会一直等于mid（mid+1==r的情况）会陷入死循环。

3. 代码实现

#include <bits/stdc++.h>

using namespace std;

const int N = 100010;

int n, m;
int q[N];

int main()
{
    cin >> n >> m;
    for (int i = 0; i < n; i ++ ) cin >> q[i];
    
    while (m -- )
    {
        int x;
        cin >> x;
        
        //查找第一个等于x的数
        int l = 0, r = n - 1;
        while (l < r)
        {
            int mid = l + r >> 1;
            if (q[mid] >= x) r = mid;
            else l = mid + 1;
        }
        if (q[l] != x) cout << "-1 -1" << endl;
        
        else
        {
            cout << l << ' ';
            
            //查找最后一个等于x的数
            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;
}

二、数的三次方根

1. 题目描述

给定一个浮点数 $n$ ，求它的三次方根。

输入格式

共一行，包含一个浮点数 $n$ 。

输出格式

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

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

数据范围

$- 10000 \leq n \leq 10000$

输入样例：

1000.00

输出样例：

10.000000

2. 思路分析

浮点数二分算法模板：

bool check(double x) {/* ... */} // 检查x是否满足某种性质

double bsearch_3(double l, double r)
{
    const double eps = 1e-6;   // eps 表示精度，取决于题目对精度的要求
    while (r - l > eps)
    {
        double mid = (l + r) / 2;
        if (check(mid)) r = mid;
        else l = mid;
    }
    return l;
}

3. 代码实现

#include <bits/stdc++.h>

using namespace std;

int main()
{
    double x;
    cin >> x;
    
    double l = -100, r = 100;
    while (r - l > 1e-8) //注意精度问题
    {
        double mid = (l + r) / 2;
        if (mid * mid * mid >= x) r = mid;
        else l = mid;
    }
    printf("%.6lf\n", l);
    return 0;
}

第四章高精度

一、高精度加法

1. 题目描述

给定两个正整数（不含前导 $0$ ），计算它们的和。

输入格式

共两行，每行包含一个整数。

输出格式

共一行，包含所求的和。

数据范围

$1 \leq 整数长度 \leq 100000$

输入样例：

12
23

输出样例：

2. 思路分析

高精度加法模板：

// C = A + B, A >= 0, B >= 0
vector<int> add(vector<int> &A, vector<int> &B)
{
    if (A.size() < B.size()) return add(B, A);

    vector<int> C;
    int t = 0;
    for (int i = 0; i < A.size(); i ++ )
    {
        t += A[i];
        if (i < B.size()) t += B[i];
        C.push_back(t % 10);
        t /= 10;
    }

    if (t) C.push_back(t);
    return C;
}

3. 代码实现

#include <bits/stdc++.h>

using namespace std;

vector<int> add(vector<int> &A, vector<int> &B)
{
    if (A.size() < B.size()) return add(B, A);

    vector<int> C;
    int t = 0; //t表示进位
    for (int i = 0; i < A.size(); i ++ )
    {
        t += A[i]; //进位加上A第i位上的数
        if (i < B.size()) t += B[i]; //进位加上B第i位上的数
        C.push_back(t % 10);  //C的值就是进位的个位数
        t /= 10; //把t的个位数去掉只剩下十位数，即只剩下这个位置的进位
    }
    
    //如果最后还剩下进位，直接加入C数组
    if (t) C.push_back(t);
    return C;
}

int main()
{
    string a, b;
    vector<int> A, B;
    cin >> a >> b;
    
    //a，b倒着放进数组中，因为有进位，倒着放容易处理
    for (int i = a.size() - 1; i >= 0; i -- ) A.push_back(a[i] - '0');
    for (int i = b.size() - 1; i >= 0; i -- ) B.push_back(b[i] - '0');

    auto C = add(A, B);

    //因为A和B是倒着放的，使所以C也要倒着输出
    for (int i = C.size() - 1; i >= 0; i -- ) cout << C[i];
    cout << endl;

    return 0;
}

二、高精度减法

1. 题目描述

给定两个正整数（不含前导 0），计算它们的差，计算结果可能为负数。

输入格式

共两行，每行包含一个整数。

输出格式

共一行，包含所求的差。

数据范围

$1≤整数长度≤10^5$

输入样例：

32
11

输出样例：

2. 思路分析

高精度减法模板：

// C = A - B, 满足A >= B, A >= 0, B >= 0
vector<int> sub(vector<int> &A, vector<int> &B)
{
    vector<int> C;
    for (int i = 0, t = 0; i < A.size(); i ++ )
    {
        t = A[i] - t;
        if (i < B.size()) t -= B[i];
        C.push_back((t + 10) % 10);
        if (t < 0) t = 1;
        else t = 0;
    }

    while (C.size() > 1 && C.back() == 0) C.pop_back();
    return C;
}

3. 代码实现

#include <bits/stdc++.h>

using namespace std;

bool cmp(vector<int> &A, vector<int> &B)
{
    if (A.size() != B.size()) return A.size() > B.size();

    for (int i = A.size() - 1; i >= 0; i -- )
        if (A[i] != B[i])
            return A[i] > B[i];

    return true;
}

vector<int> sub(vector<int> &A, vector<int> &B)
{
    vector<int> C;
    for (int i = 0, t = 0; i < A.size(); i ++ )
    {
        t = A[i] - t;
        if (i < B.size()) t -= B[i];
        C.push_back((t + 10) % 10);
        if (t < 0) t = 1;
        else t = 0;
    }

    while (C.size() > 1 && C.back() == 0) C.pop_back();
    return C;
}

int main()
{
    string a, b;
    vector<int> A, B;
    cin >> a >> b;
    for (int i = a.size() - 1; i >= 0; i -- ) A.push_back(a[i] - '0');
    for (int i = b.size() - 1; i >= 0; i -- ) B.push_back(b[i] - '0');

    vector<int> C;

    if (cmp(A, B)) C = sub(A, B);
    else C = sub(B, A), cout << '-';

    for (int i = C.size() - 1; i >= 0; i -- ) cout << C[i];
    cout << endl;

    return 0;
}

三、高精度乘法

1. 题目描述

给定两个非负整数（不含前导 00） AA 和 BB，请你计算 A×BA×B 的值。

输入格式

共两行，第一行包含整数 $A$ ，第二行包含整数 $B$ 。

输出格式

共一行，包含 $A \times B$ 的值。

数据范围

$1 \leq A 的长度 \leq 100000$ ,
$0 \leq B \leq 10000$

输入样例：

2
3

输出样例：

2. 思路分析

高精度乘低精度模板：

// C = A * b, A >= 0, b >= 0
vector<int> mul(vector<int> &A, int b)
{
    vector<int> C;

    int t = 0;
    for (int i = 0; i < A.size() || t; i ++ )
    {
        if (i < A.size()) t += A[i] * b;
        C.push_back(t % 10);
        t /= 10;
    }

    while (C.size() > 1 && C.back() == 0) C.pop_back();

    return C;
}

3. 代码实现

#include <bits/stdc++.h>

using namespace std;


vector<int> mul(vector<int> &A, int b)
{
    vector<int> C;

    int t = 0;
    for (int i = 0; i < A.size() || t; i ++ )
    {
        if (i < A.size()) t += A[i] * b;
        C.push_back(t % 10);
        t /= 10;
    }

    while (C.size() > 1 && C.back() == 0) C.pop_back();

    return C;
}


int main()
{
    string a;
    int b;

    cin >> a >> b;

    vector<int> A;
    for (int i = a.size() - 1; i >= 0; i -- ) A.push_back(a[i] - '0');

    auto C = mul(A, b);

    for (int i = C.size() - 1; i >= 0; i -- ) printf("%d", C[i]);

    return 0;
}

四、高精度除法

1. 题目描述

给定两个非负整数（不含前导 00） $A ， B$ ，请你计算 $A / B$ 的商和余数。

输入格式

共两行，第一行包含整数 $A$ ，第二行包含整数 $B$ 。

输出格式

共两行，第一行输出所求的商，第二行输出所求余数。

数据范围

$1 \leq A 的长度 \leq 100000$ ,
$1 \leq B \leq 10000$ ,
$B$ 一定不为 $0$

输入样例：

7
2

输出样例：

3
1

2. 思路分析

高精度除以低精度模板：

// A / b = C ... r, A >= 0, b > 0
vector<int> div(vector<int> &A, int b, int &r)
{
    vector<int> C;
    r = 0;
    for (int i = A.size() - 1; i >= 0; i -- )
    {
        r = r * 10 + A[i];
        C.push_back(r / b);
        r %= b;
    }
    reverse(C.begin(), C.end());
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    return C;
}

3. 代码实现

#include <bits/stdc++.h>

using namespace std;

vector<int> div(vector<int> &A, int b, int &r)
{
    vector<int> C;
    r = 0;
    for (int i = A.size() - 1; i >= 0; i -- )
    {
        r = r * 10 + A[i];
        C.push_back(r / b);
        r %= b;
    }
    reverse(C.begin(), C.end());
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    return C;
}

int main()
{
    string a;
    vector<int> A;

    int B;
    cin >> a >> B;
    for (int i = a.size() - 1; i >= 0; i -- ) A.push_back(a[i] - '0');

    int r;
    auto C = div(A, B, r);

    for (int i = C.size() - 1; i >= 0; i -- ) cout << C[i];

    cout << endl << r << endl;

    return 0;
}

创作不易，如果有帮助到你，请给文章点个赞和收藏，让更多的人看到！！！
关注博主不迷路，内容持续更新中。

Java技术一点通

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
算法基础复盘笔记Day01【算法基础】—— 快速排序、归并排序、二分、高精度

首先设定一个**分界值**，将数组分为左右两部分。将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于或等于分界值。左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数
复制链接

扫一扫