算法学习记录（基于acwing算法基础课）

最新推荐文章于 2023-06-08 09:39:42 发布

moyexa

最新推荐文章于 2023-06-08 09:39:42 发布

阅读量241

点赞数 2

文章标签：算法

本文链接：https://blog.csdn.net/weixin_51662463/article/details/118992031

版权

1.归并排序

题目如下

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

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

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

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

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

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

数据范围
1≤n≤100000
输入样例：
5
3 1 2 4 5
输出样例：
1 2 3 4 5

思想：将整个数分为两段，使用双指针，同时指向前面那段和后面那段，比较两个指针，较小的则往后移，一直到一个指针指到最后为止。
在这里插入图片描述
算法实现：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define IOS                     \
    ios::sync_with_stdio(false);\
    cin.tie(0)

// *start on @date: 2021-07-22 10:04
const int maxn=1e5+10;
int q[maxn]; //原数组
int temp[maxn];//临时数组
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(int i=l,j=0;i<=r;i++,j++)//放入原数组
    { 
        q[i]=temp[j];
    }
}
int main() 
{
    IOS;
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>q[i];
    }
    merge_sort(q,0,n-1);
    for(int i=0;i<n;i++)
    {
        cout<<q[i]<<" ";
    }
    return 0;
}

2.逆序对的数量

题目如下

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

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

输入格式
第一行包含整数 n，表示数列的长度。

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

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

数据范围
1≤n≤100000
输入样例：
6
2 3 4 5 6 1
输出样例：
5

逆序对概念：前一个数大于后一个数，这样的数所构成的数对即为逆序对。
思想：同理运用了上面归并排序的算法，照样将给定的数列分成两部分，分为下列三种情况：

两个数都在左边
两个数都在右边
一个数在左边一个数在右边

情况一：merge_sort(L,mid)
情况二：merge_sort(mid+1,R)
情况三：当前两种情况输出完毕时，左边的当前位置向后必定比右边的都大，加上mid-i+1

在这里插入图片描述

算法实现：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e5+10;
int q[maxn],temp[maxn];
ll merge_sort(int l,int r)
{
    if(l>=r)
    {
        return 0;
    }
    int mid=l+r>>1;
    ll res=merge_sort(l,mid)+merge_sort(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++];
            res+=mid-i+1;//i>j时加上中间那段
        }
    }
    while(i<=mid)
    {
        temp[k++]=q[i++];
    }
    while(j<=r)
    {
        temp[k++]=q[j++];
    }
    for(int i=l,j=0;i<=r;i++,j++)
    { 
        q[i]=temp[j];
    }
    return res;
}
int main() 
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>q[i]; 
    }
    cout<<merge_sort(0,n-1)<<endl;
    return 0;
}

3.数的范围（整数二分）

题目如下

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

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

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

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

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

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

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

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

数据范围
1≤n≤100000
1≤q≤10000
1≤k≤10000
输入样例：
6 3
1 2 2 3 3 4
3
4
5
输出样例：
3 4
5 5
-1 -1

思想：分成两块，可以是左边，mid=(L+R)/2，也可以是右边，mid=(L+R+1)/2

从左边来看：
true(L->mid):R=mid(L->mid)
false(mid+1->R):L=mid+1(mid+1->R)
从右边来看：
true(L->mid):L=mid(mid->R)
false(mid+1->R):R=mid-1(L->mid-1)
在这里插入图片描述
算法实现：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define IOS                      \
    ios::sync_with_stdio(false); \
    cin.tie(0)

// *start on @date: 2021-05-18 15:00
const int maxn = 1e5 + 10;
int a[maxn];
int n, m, l, r;
int main()
{
    IOS;
    cin >> n >> m;
    for (int i = 0; i < n; i++)
    {
        cin >> a[i];
    }
    for (int i = 0; i < m; i++)
    {
        int x;
        cin >> x;
        l = 0;
        r = n - 1;
        while (l < r)
        {
            int mid = l + r >> 1;//左边
            if (a[mid] >= x)
            {
                r = mid;
            }
            else
            {
                l = mid + 1;
            }
        }
        if (a[l] != x)
        {
            cout << "-1 -1" << endl;
        }
        else//右边
        {
            cout << l << " ";
            l = 0;
            r = n - 1;
            while (l < r)
            {
                int mid = l + r + 1 >> 1;//右边
                if (a[mid] <= x)
                {
                    l = mid;
                }
                else
                {
                    r = mid - 1;
                }
            }
            cout << l << endl;
        }
    }
    return 0;
}

4.数的三次方根（浮点数二分）

题目如下
给定一个浮点数 n，求它的三次方根。

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

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

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

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

思路：二分判断，无需注意中心点问题。
注：要注意是否有不在范围内的情况，如本题若有0.001，三次方根为0.1，可能超出范围。

算法实现：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define IOS                      \
    ios::sync_with_stdio(false); \
    cin.tie(0)

// *start on @date: 2021-07-22 09:37

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

5.高精度加法

题目如下

给定两个正整数，计算它们的和。

输入格式
共两行，每行包含一个整数。

输出格式
共一行，包含所求的和。

数据范围
1≤整数长度≤100000
输入样例：
12
23
输出样例：
35

思想：从后往前看有没有进位，进行计算。

在这里插入图片描述
算法实现：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e6+10;
vector<int>add(vector <int> &A,vector <int> &B)
{
    vector<int> C;
    int t=0;
    for(int i=0;i<A.size()||i<B.size();i++)
    {
        if(i<A.size())
        {
            t+=A[i];
        }
        if(i<B.size())
        {
            t+=B[i];
        }
        C.push_back(t%10);//得到的数字压入
        t/=10;//看有没有进位
    }
    if(t)
    {
        C.push_back(1);//看最后要不要加1
    }
    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');
    }
    auto C=add(A,B);
    for(int i=C.size()-1;i>=0;i--)
    {
        cout<<C[i];
    }
    return 0;
}

6.高精度减法

题目如下

给定两个正整数，计算它们的差，计算结果可能为负数。

输入格式
共两行，每行包含一个整数。

输出格式
共一行，包含所求的差。

数据范围
1≤整数长度≤105
输入样例：
32
11
输出样例：
21

思路：判断是A大还是B大，如果A大就是A在前，如果B大就是B在前并在结果前面加一个负号，其余通上，不过要注意当结果前面有很多前导零时要把前导零去掉。
在这里插入图片描述
算法实现：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e6+10;
bool cmp(vector <int> &A,vector <int> &B)//判断A>=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;
    cin>>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');
    }
    if(cmp(A,B))//比较，判断A大还是B大
    {
    auto C=sub(A,B);
    for(int i=C.size()-1;i>=0;i--)
    {
        cout<<C[i];
    }
    }
    else
    {
        auto C=sub(B,A);
        cout<<"-";  
        for(int i=C.size()-1;i>=0;i--)
        {
            cout<<C[i];
        }
    }
    return 0;
}

7.高精度乘法

题目如下

给定两个正整数 A 和 B，请你计算 A×B 的值。

输入格式
共两行，第一行包含整数 A，第二行包含整数 B。

输出格式
共一行，包含 A×B 的值。

数据范围
1≤A的长度≤100000,
0≤B≤10000
输入样例：
2
3
输出样例：
6

思路：和加法思路一样，用t记录进位，去掉前导零。（高位低位）

算法实现：
1.（高精度低精度）

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e6+10;
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;
    vector<int> A;
    cin>>a>>b;
    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--)
    {
        cout<<C[i];
    }
    return 0;
}

1.（高精度*高精度）

#include <iostream>
#include <vector>

using namespace std;

vector<int> mul(vector<int> A, vector<int> B)
{
    vector<int> C(A.size() + B.size());

    for (int i = 0; i < A.size(); i ++ )
        for (int j = 0; j < B.size(); j ++ )
            C[i + j] += A[i] * B[j];

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

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

    return C;
}

int main()
{
    string a, b;
    cin >> a >> b;
    vector<int> 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 = mul(A, B);

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

    return 0;
}

8.高精度除法

题目如下

给定两个非负整数 A，B，请你计算 A/B 的商和余数。

输入格式
共两行，第一行包含整数 A，第二行包含整数 B。

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

数据范围
1≤A的长度≤100000,
1≤B≤10000,
B 一定不为 0
输入样例：
7
2
输出样例：
3
1

思路：与乘法类似，不过是反过来了，从前往后，记录余数，并去掉前导零，函数中加一个参数用于记录余数。
在这里插入图片描述
算法实现：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e6+10;
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;
    int b;
    vector<int> A;
    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;
}

9.前缀和

题目如下

输入一个长度为 n 的整数序列。

接下来再输入 m 个询问，每个询问输入一对 l,r。

对于每个询问，输出原序列中从第 l 个数到第 r 个数的和。

输入格式
第一行包含两个整数 n 和 m。

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

接下来 m 行，每行包含两个整数 l 和 r，表示一个询问的区间范围。

输出格式
共 m 行，每行输出一个询问的结果。

数据范围
1≤l≤r≤n,
1≤n,m≤100000,
−1000≤数列中元素的值≤1000
输入样例：
5 3
2 1 3 6 4
1 2
1 3
2 4
输出样例：
3
6
10

思路：查询只需要用一个公式，查询从[L->R]这个区间内的前缀和，只需要用s[R]-s[L-1]，即可得到这个区间内的值。

算法实现：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define IOS                     \
    ios::sync_with_stdio(false);\
    cin.tie(0)

// *start on @date: 2021-07-28 12:36 
const int maxn=1e6+10;
int a[maxn],s[maxn];
int main() 
{
    IOS;
    int n,m,temp1,temp2;
    cin>>n>>m;
    for(int i=1;i<=n;i++)//从1开始遍历
    {
        cin>>a[i];
    }
    s[0]=0;
    for(int i=1;i<=n;i++)
    {
        s[i]=s[i-1]+a[i];
    }
    // for(int i=1;i<n;i++)
    // {
    //     cout<<s[i]<<endl;
    // }
    for(int i=0;i<m;i++)//利用算式
    {
        cin>>temp1>>temp2;
        cout<<s[temp2]-s[temp1-1]<<endl;
    }
    return 0;
}

10.子矩阵的和

题目如下

输入一个 n 行 m 列的整数矩阵，再输入 q 个询问，每个询问包含四个整数 x1,y1,x2,y2，表示一个子矩阵的左上角坐标和右下角坐标。

对于每个询问输出子矩阵中所有数的和。

输入格式
第一行包含三个整数 n，m，q。

接下来 n 行，每行包含 m 个整数，表示整数矩阵。

接下来 q 行，每行包含四个整数 x1,y1,x2,y2，表示一组询问。

输出格式
共 q 行，每行输出一个询问的结果。

数据范围
1≤n,m≤1000,
1≤q≤200000,
1≤x1≤x2≤n,
1≤y1≤y2≤m,
−1000≤矩阵内元素的值≤1000
输入样例：
3 4 3
1 7 2 4
3 6 2 8
2 1 2 3
1 1 2 2
2 1 3 4
1 3 3 4
输出样例：
17
27
21

思路：将s[i][j]以矩阵的方式进行存储，s[i][j]=s[i-1][j]+s[i][j-1]-s[i-1][j-1]+a[i][j]，如下图所示：
在这里插入图片描述
求范围内子矩阵的和公式如下：s[x2][y2]-s[x1-1][y2]-s[x2][y1-1]+s[x1-1][y1-1]

算法实现：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define IOS                     \
    ios::sync_with_stdio(false);\
    cin.tie(0)

// *start on @date: 2021-07-28 17:55 
const int maxn=1e3+10;
int a[maxn][maxn],s[maxn][maxn];
int main() 
{
    IOS;
    int n,m,q,x1,x2,y1,y2;
    cin>>n>>m>>q;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            cin>>a[i][j];
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            s[i][j]=s[i-1][j]+s[i][j-1]-s[i-1][j-1]+a[i][j];//存s[i][j]
        }
    }
    for(int i=0;i<q;i++)
    {
        cin>>x1>>y1>>x2>>y2;
        cout<<(s[x2][y2]-s[x1-1][y2]-s[x2][y1-1]+s[x1-1][y1-1])<<endl;//计算范围内的子矩阵的和
    }
    return 0;
}

11.差分

题目如下

输入一个长度为 n 的整数序列。

接下来输入 m 个操作，每个操作包含三个整数 l,r,c，表示将序列中 [l,r] 之间的每个数加上 c。

请你输出进行完所有操作后的序列。

输入格式
第一行包含两个整数 n 和 m。

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

接下来 m 行，每行包含三个整数 l，r，c，表示一个操作。

输出格式
共一行，包含 n 个整数，表示最终序列。

数据范围
1≤n,m≤100000,
1≤l≤r≤n,
−1000≤c≤1000,
−1000≤整数序列中元素的值≤1000
输入样例：
6 3
1 2 2 1 2 1
1 3 1
3 5 1
1 6 1
输出样例：
3 4 5 3 4 2

思路：假设a[i],b[i]都是0,b[i]的前缀和等于a[i],向b[i]里面插入数据，其实就是在前缀和的基础上在一个范围内加上一个固定的值，用insert方便操作,对b[l]每个都加上c相当于a[l]到a[n]都加了c,所以要再减去b[r+1],得到的则是a[l]到a[r]这个范围内的每一个值都加上c。
在这里插入图片描述
算法实现：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define IOS                     \
    ios::sync_with_stdio(false);\
    cin.tie(0)

// *start on @date: 2021-07-30 08:58 
const int maxn=1e5+10;
int n,m;
int a[maxn],b[maxn];
void insert(int l,int r,int c)
{
    b[l]+=c;
    b[r+1]-=c;
}
int main() 
{
    IOS;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
    }
    for(int i=1;i<=n;i++)
    {
        insert(i,i,a[i]);//实现b[1]=a[1];b[2]=a[2]-a[1];b[3]=a[3]-a[2];...b[n]=a[n]-a[n-1];
    }
    while(m--)
    {
        int l,r,c;
        cin>>l>>r>>c;
        insert(l,r,c);//对每一个加上c
    }
    for(int i=1;i<=n;i++)
    {
        b[i]+=b[i-1];//变成b[i]=a[i]+c
    }
    for(int i=1;i<=n;i++)
    {
        cout<<b[i]<<" ";//输出
    }
    return 0;
}

12.差分矩阵

题目如下

输入一个 n 行 m 列的整数矩阵，再输入 q 个操作，每个操作包含五个整数 x1,y1,x2,y2,c，其中 (x1,y1) 和 (x2,y2) 表示一个子矩阵的左上角坐标和右下角坐标。

每个操作都要将选中的子矩阵中的每个元素的值加上 c。

请你将进行完所有操作后的矩阵输出。

输入格式
第一行包含整数 n,m,q。

接下来 n 行，每行包含 m 个整数，表示整数矩阵。

接下来 q 行，每行包含 5 个整数 x1,y1,x2,y2,c，表示一个操作。

输出格式
共 n 行，每行 m 个整数，表示所有操作进行完毕后的最终矩阵。

数据范围
1≤n,m≤1000,
1≤q≤100000,
1≤x1≤x2≤n,
1≤y1≤y2≤m,
−1000≤c≤1000,
−1000≤矩阵内元素的值≤1000
输入样例：
3 4 3
1 2 2 1
3 2 2 1
1 1 1 1
1 1 2 2 1
1 3 2 3 2
3 1 3 4 1
输出样例：
2 3 4 1
4 3 4 1
2 2 2 2

思路：与上面的子矩阵的和的解法类似，如图所示：
在这里插入图片描述
算法实现：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define IOS                     \
    ios::sync_with_stdio(false);\
    cin.tie(0)

// *start on @date: 2021-07-30 10:24 
int n,m,q;
const int maxn=1e3+10;
int a[maxn][maxn],b[maxn][maxn];
void insert(int x1,int y1,int x2,int y2,int c)
{
    b[x1][y1]+=c;
    b[x2+1][y1]-=c;
    b[x1][y2+1]-=c;
    b[x2+1][y2+1]+=c;
}
int main() 
{
    IOS;
    cin>>n>>m>>q;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            cin>>a[i][j];
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            insert(i,j,i,j,a[i][j]);
        }
    }
    while(q--)
    {
        int x1,y1,x2,y2,c;
        cin>>x1>>y1>>x2>>y2>>c;
        insert(x1,y1,x2,y2,c);
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            b[i][j]+=b[i-1][j]+b[i][j-1]-b[i-1][j-1];
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            cout<<b[i][j]<<" ";
        }
        cout<<endl;
    }
    return 0;
}

moyexa

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
算法学习记录（基于acwing算法基础课）

1.归并排序题目如下给定你一个长度为 n 的整数数列。请你使用归并排序对这个数列按照从小到大进行排序。并将排好序的数列按顺序输出。输入格式输入共两行，第一行包含整数 n。第二行包含 n 个整数（所有整数均在 1∼109 范围内），表示整个数列。输出格式输出共一行，包含 n 个整数，表示排好序的数列。数据范围1≤n≤100000输入样例：53 1 2 4 5输出样例：1 2 3 4 5思想：将整个数分为两段，使用双指针，同时指向前面那段和后面那段，比较两个指针，较小的则往后移
复制链接

扫一扫