算法笔记--数列分块

模板：

const int N=1e5+5;
int a[N],belong[N]/*属于哪个块*/,blo/*块的大小*/,block[1000];
void update(int l,int r){
    if(belong[l]==belong[r]){
        for(int i=l;i<=r;i++){
            //你的操作
        }
        return ;
    }
    for(int i=l;i<=belong[l]*blo;i++){
        //你的操作
    }
    for(int i=belong[l]+1;i<=belong[r]-1;i++){
        //你的操作
    }
    for(int i=(belong[r]-1)*blo+1;i<=r;i++){
        //你的操作
    }
}
int query(int l,int r){
    int ans=0;
    if(belong[l]==belong[r]){
        for(int i=l;i<=r;i++){
            //你的操作
        }
        return ans;
    }
    for(int i=l;i<=belong[l]*blo;i++){
        //你的操作
    }
    for(int i=belong[l]+1;i<=belong[r]-1;i++){
        //你的操作
    }
    for(int i=(belong[r]-1)*blo+1;i<=r;i++){
        //你的操作
    }
    return ans;
}

数列分块入门 1

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))

const int N=5e4+5;
int belong[N],a[N],block[1000],b;
void add(int l,int r,int c){
    if(belong[l]==belong[r]){
        for(int i=l;i<=r;i++)
        a[i]+=c;
        return ;
    }
    for(int i=l;i<=belong[l]*b;i++)a[i]+=c;
    for(int i=belong[l]+1;i<=belong[r]-1;i++)block[i]+=c;
    for(int i=(belong[r]-1)*b+1;i<=r;i++)a[i]+=c;

}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n,o,l,r,c;
    cin>>n;
    b=sqrt(n);
    for(int i=1;i<=n;i++)cin>>a[i];
    for(int i=1;i<=n;i++)belong[i]=(i-1)/b+1;
    for(int i=1;i<=n;i++){
        cin>>o>>l>>r>>c;
        if(o==0)add(l,r,c);
        else cout<<a[r]+block[belong[r]]<<endl;
    }
    return 0;
}

数列分块入门 2

新技能：边缘块的重置

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))

const int N=5e4+5;
int a[N],belong[N],block[1000],blo;
vector<int>vc[1000];
void reset(int x){
    vc[x].clear();
    for(int i=(x-1)*blo+1;i<=x*blo;i++)vc[x].pb(a[i]);
    sort(vc[x].begin(),vc[x].end());
}
void add(int l,int r,int c){
    if(belong[l]==belong[r]){
        for(int i=l;i<=r;i++)a[i]+=c;
        reset(belong[l]);
        return ;
    }
    for(int i=l;i<=belong[l]*blo;i++)a[i]+=c;
    reset(belong[l]);
    for(int i=belong[l]+1;i<=belong[r]-1;i++)block[i]+=c;
    for(int i=(belong[r]-1)*blo+1;i<=r;i++)a[i]+=c;
    reset(belong[r]);
}
int query(int l,int r,int c){
    int ans=0;
    if(belong[l]==belong[r]){
        for(int i=l;i<=r;i++)if(a[i]+block[belong[i]]<c)ans++;
        return ans;
    }
    for(int i=l;i<=belong[l]*blo;i++)if(a[i]+block[belong[i]]<c)ans++;
    for(int i=belong[l]+1;i<=belong[r]-1;i++){
        int x=c-block[i];
        ans+=lower_bound(vc[i].begin(),vc[i].end(),x)-vc[i].begin();
    }
    for(int i=(belong[r]-1)*blo+1;i<=r;i++)if(a[i]+block[belong[i]]<c)ans++;
    return ans;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n,o,l,r,c;
    cin>>n;
    blo=sqrt(n);
    for(int i=1;i<=n;i++)cin>>a[i];
    for(int i=1;i<=n;i++){
        belong[i]=(i-1)/blo+1;
        vc[belong[i]].pb(a[i]);
    }
    for(int i=1;i<=belong[n];i++)sort(vc[i].begin(),vc[i].end());
    for(int i=1;i<=n;i++){
        cin>>o>>l>>r>>c;
        if(o==0)add(l,r,c);
        else cout<<query(l,r,c*c)<<endl;
    }
    return 0;
}

数列分块入门 3

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))

const int N=1e5+5;
int a[N],belong[N],block[1000],blo;
vector<int>vc[1000];
void reset(int x){
    vc[x].clear();
    for(int i=(x-1)*blo+1;i<=x*blo;i++)vc[x].pb(a[i]);
    sort(vc[x].begin(),vc[x].end());
}
void add(int l,int r,int c){
    if(belong[l]==belong[r]){
        for(int i=l;i<=r;i++)a[i]+=c;
        reset(belong[l]);
        return ;
    }
    for(int i=l;i<=belong[l]*blo;i++)a[i]+=c;
    reset(belong[l]);
    for(int i=belong[l]+1;i<=belong[r]-1;i++)block[i]+=c;
    for(int i=(belong[r]-1)*blo+1;i<=r;i++)a[i]+=c;
    reset(belong[r]);
}
int query(int l,int r,int c){
    int ans=-1;
    if(belong[l]==belong[r]){
        for(int i=l;i<=r;i++)if(a[i]+block[belong[i]]<c)ans=max(ans,a[i]+block[belong[i]]);
        return ans;
    }
    for(int i=l;i<=belong[l]*blo;i++)if(a[i]+block[belong[i]]<c)ans=max(ans,a[i]+block[belong[i]]);
    for(int i=belong[l]+1;i<=belong[r]-1;i++){
        int x=c-block[i];
        int t=lower_bound(vc[i].begin(),vc[i].end(),x)-vc[i].begin();
        if(t!=0)ans=max(ans,vc[i][t-1]+block[i]);
    }
    for(int i=(belong[r]-1)*blo+1;i<=r;i++)if(a[i]+block[belong[i]]<c)ans=max(ans,a[i]+block[belong[i]]);
    return ans;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n,o,l,r,c;
    cin>>n;
    blo=sqrt(n);
    for(int i=1;i<=n;i++)cin>>a[i];
    for(int i=1;i<=n;i++){
        belong[i]=(i-1)/blo+1;
        vc[belong[i]].pb(a[i]);
    }
    for(int i=1;i<=belong[n];i++)sort(vc[i].begin(),vc[i].end());
    for(int i=1;i<=n;i++){
        cin>>o>>l>>r>>c;
        if(o==0)add(l,r,c);
        else cout<<query(l,r,c)<<endl;
    }
    return 0;
}

数列分块入门 4

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))

const int N=1e5+5;
int a[N],belong[N],blo;
ll sum[1000],block[1000];
void add(int l,int r,int c){
    if(belong[l]==belong[r]){
        for(int i=l;i<=r;i++)a[i]+=c,sum[belong[i]]+=c;
        return ;
    }
    for(int i=l;i<=belong[l]*blo;i++)a[i]+=c,sum[belong[i]]+=c;
    for(int i=belong[l]+1;i<=belong[r]-1;i++)block[i]+=c;
    for(int i=(belong[r]-1)*blo+1;i<=r;i++)a[i]+=c,sum[belong[i]]+=c;
}
ll query(int l,int r,int c){
    ll ans=0;
    if(belong[l]==belong[r]){
        for(int i=l;i<=r;i++)ans=(ans+a[i]+block[belong[i]]);
        return ans;
    }
    for(int i=l;i<=belong[l]*blo;i++)ans=(ans+a[i]+block[belong[i]]);
    for(int i=belong[l]+1;i<=belong[r]-1;i++)ans=(ans+sum[i]+blo*block[i]);
    for(int i=(belong[r]-1)*blo+1;i<=r;i++)ans=(ans+a[i]+block[belong[i]]);
    return ans;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n,o,l,r,c;
    cin>>n;
    blo=sqrt(n);
    for(int i=1;i<=n;i++)cin>>a[i];
    for(int i=1;i<=n;i++){
        belong[i]=(i-1)/blo+1;
        sum[belong[i]]+=a[i];
    }
    for(int i=1;i<=n;i++){
        cin>>o>>l>>r>>c;
        if(o==0)add(l,r,c);
        else cout<<query(l,r,c)%(c+1)<<endl;
    }
    return 0;
}

数列分块入门 5

套路套路

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))

const int N=1e5+5;
int a[N],belong[N],blo,flag[1000];
ll sum[1000];
void solve_sqrt(int x){
    if(flag[x])return ;
    flag[x]=1;
    sum[x]=0;
    for(int i=(x-1)*blo+1;i<=x*blo;i++){
        a[i]=sqrt(a[i]);
        sum[x]+=a[i];
        if(a[i]>1)flag[x]=0;
    }
}
void update(int l,int r){
    if(belong[l]==belong[r]){
        for(int i=l;i<=r;i++){
            sum[belong[i]]-=a[i];
            a[i]=sqrt(a[i]);
            sum[belong[i]]+=a[i];
        }
        return ;
    }
    for(int i=l;i<=belong[l]*blo;i++){
        sum[belong[i]]-=a[i];
        a[i]=sqrt(a[i]);
        sum[belong[i]]+=a[i];
    }
    for(int i=belong[l]+1;i<=belong[r]-1;i++)solve_sqrt(i);
    for(int i=(belong[r]-1)*blo+1;i<=r;i++){
        sum[belong[i]]-=a[i];
        a[i]=sqrt(a[i]);
        sum[belong[i]]+=a[i];
    }
}
ll query(int l,int r){
    ll ans=0;
    if(belong[l]==belong[r]){
        for(int i=l;i<=r;i++)ans+=a[i];
        return ans;
    }
    for(int i=l;i<=belong[l]*blo;i++)ans+=a[i];
    for(int i=belong[l]+1;i<=belong[r]-1;i++)ans+=sum[i];
    for(int i=(belong[r]-1)*blo+1;i<=r;i++)ans+=a[i];
    return ans;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n,o,l,r,c;
    cin>>n;
    blo=sqrt(n);
    for(int i=1;i<=n;i++)cin>>a[i];
    for(int i=1;i<=n;i++){
        belong[i]=(i-1)/blo+1;
        sum[belong[i]]+=a[i];
    }
    for(int i=1;i<=n;i++){
        cin>>o>>l>>r>>c;
        if(o==0)update(l,r);
        else cout<<query(l,r)<<endl;
    }
    return 0;
}

数列分块入门 6

新技能：单块过大，重建块

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define mem(a,b) memset(a,b,sizeof(a))

const int N=2e5+5;
int a[N],belong[N],blo,m;
vector<int>vc[1000];
pii query(int a){
    int top=1;
    while(a>vc[top].size())a-=vc[top++].size();
    return mp(top,a-1);
}
void rebuild(){
    int top=0;
    for(int i=1;i<=m;i++){
        for(int j=0;j<vc[i].size();j++)
        a[++top]=vc[i][j];
        vc[i].clear();
    }
    for(int i=1;i<=top;i++)belong[i]=(i-1)/blo+1,vc[belong[i]].pb(a[i]);
    m=belong[top];
}
void insert(int a,int b){
    pii t=query(a);
    vc[t.first].insert(vc[t.first].begin()+t.second,b);
    if(vc[t.first].size()>15*blo)rebuild();
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n,o,l,r,c;
    cin>>n;
    blo=sqrt(n);
    for(int i=1;i<=n;i++){
        cin>>a[i];
        belong[i]=(i-1)/blo+1;
        vc[belong[i]].pb(a[i]);
    }
    m=belong[n];
    for(int i=1;i<=n;i++){
        cin>>o>>l>>r>>c;
        if(o==0)insert(l,r);
        else{
            pii t=query(r);
            cout<<vc[t.first][t.second]<<endl;
        }
    }
    return 0;
}

数列分块入门 7

新技能：乘法和加法的标记

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))

const int N=1e5+5;
const int MOD=1e4+7;
ll a[N],belong[N],tim[1000],plu[1000];
int n,blo;
void reset(int x){
    for(int i=(x-1)*blo+1;i<=min(x*blo,n);i++)a[i]=(a[i]*tim[belong[i]]+plu[belong[i]])%MOD;
    tim[x]=1;plu[x]=0;
}
void add(int l,int r,int c){
    if(belong[l]==belong[r]){
        reset(belong[l]);
        for(int i=l;i<=r;i++){
            a[i]+=c;
            a[i]%=MOD;
        }
        return ;
    }
    reset(belong[l]);
    for(int i=l;i<=belong[l]*blo;i++){
        a[i]+=c;
        a[i]%=MOD;
    }
    for(int i=belong[l]+1;i<=belong[r]-1;i++){
        plu[i]+=c;
        plu[i]%=MOD;
    }
    reset(belong[r]);
    for(int i=(belong[r]-1)*blo+1;i<=r;i++){
        a[i]+=c;
        a[i]%=MOD;
    }
}
void mul(int l,int r,int c){
    if(belong[l]==belong[r]){
        reset(belong[l]);
        for(int i=l;i<=r;i++){
            a[i]*=c;
            a[i]%=MOD;
        }
        return ;
    }
    reset(belong[l]);
    for(int i=l;i<=belong[l]*blo;i++){
        a[i]*=c;
        a[i]%=MOD;
    }
    for(int i=belong[l]+1;i<=belong[r]-1;i++){
        plu[i]*=c;
        plu[i]%=MOD;
        tim[i]*=c;
        tim[i]%=MOD;
    }
    reset(belong[r]);
    for(int i=(belong[r]-1)*blo+1;i<=r;i++){
        a[i]*=c;
        a[i]%=MOD;
    }
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int o,l,r,c;
    cin>>n;
    blo=sqrt(n);
    for(int i=1;i<=n;i++){
        cin>>a[i];
        belong[i]=(i-1)/blo+1;
    }
    for(int i=1;i<=belong[n];i++)tim[i]=1;
    for(int i=1;i<=n;i++){
        cin>>o>>l>>r>>c;
        if(o==0){
            add(l,r,c);
        }
        else if(o==1){
            mul(l,r,c);
        }
        else{
            cout<<(a[r]*tim[belong[r]]+plu[belong[r]])%MOD<<endl;
        }
    }
    return 0;
}

数列分块入门 8

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))

const int N=1e5+5;
int a[N],belong[N],blo,block[1000];
void reset(int x){
    for(int i=(x-1)*blo+1;i<=x*blo;i++){
        a[i]=block[belong[i]];
    }
    block[x]=-1;
}
int query(int l,int r,int c){
    int ans=0;
    if(belong[l]==belong[r]){
        if(block[belong[l]]!=-1)reset(belong[l]);
        for(int i=l;i<=r;i++){
            if(a[i]!=c)a[i]=c;
            else ans++;
        }
        return ans;
    }
    if(block[belong[l]]!=-1)reset(belong[l]);
    for(int i=l;i<=belong[l]*blo;i++){
        if(a[i]!=c)a[i]=c;
        else ans++;
    }
    for(int i=belong[l]+1;i<=belong[r]-1;i++){
        if(block[i]!=-1){
                if(block[i]!=c)block[i]=c;
                else ans+=blo;
        }
        else{
            for(int j=(i-1)*blo+1;j<=i*blo;j++){
                if(a[j]!=c)a[j]=c;
                else ans++;
            }
            block[i]=c;
        }
    }
    if(block[belong[r]]!=-1)reset(belong[r]);
    for(int i=(belong[r]-1)*blo+1;i<=r;i++){
        if(a[i]!=c)a[i]=c;
        else ans++;
    }
    return ans;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    mem(block,-1);
    int n,o,l,r,c;
    cin>>n;
    blo=sqrt(n);
    for(int i=1;i<=n;i++){
        cin>>a[i];
        belong[i]=(i-1)/blo+1;
    }
    for(int i=1;i<=n;i++){
        cin>>l>>r>>c;
        cout<<query(l,r,c)<<endl;
    }
    return 0;
}

数列分块入门 9

区间众数

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a)) 

const int N=1e5+5;
int a[N],belong[N],blo,cnt[N],val[N];
vector<int>pos[N];
vector<int>v;
int f[1000][1000];
int n,l,r;
void init(int x){
    mem(cnt,0);
    int mx=0,c=0;
    for(int i=(x-1)*blo+1;i<=n;i++){
        cnt[a[i]]++;
        if(cnt[a[i]]>c){
            c=cnt[a[i]];
            mx=a[i];
        }
        else if(cnt[a[i]]==c&&a[i]<mx){
            mx=a[i];
        }
        f[x][belong[i]]=mx;
    }
}
int cont(int l,int r,int x){
    return upper_bound(pos[x].begin(),pos[x].end(),r)-lower_bound(pos[x].begin(),pos[x].end(),l);
}
int query(int l,int r){
    int ans=0,c=0;
    if(l==r){
        for(int i=l;i<=r;i++){
            int t=cont(l,r,a[i]);
            if(t>c){
                c=t;
                ans=a[i];
            }
            else if(t==c&&a[i]<ans){
                ans=a[i];
            }
        }
        return ans;
    }
    ans=f[belong[l]+1][belong[r]-1];
    c=cont(l,r,ans);
    for(int i=l;i<=belong[l]*blo;i++){
        int t=cont(l,r,a[i]);
        if(t>c){
            c=t;
            ans=a[i];
        }
        else if(t==c&&a[i]<ans){
            ans=a[i];
        }
    }
    for(int i=(belong[r]-1)*blo+1;i<=r;i++){
        int t=cont(l,r,a[i]);
        if(t>c){
            c=t;
            ans=a[i];
        }
        else if(t==c&&a[i]<ans){
            ans=a[i];
        }
    }
    return ans;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>n;
    blo=sqrt(n);
    for(int i=1;i<=n;i++){
        cin>>a[i];
        v.pb(a[i]);
        belong[i]=(i-1)/blo+1;
    }
    sort(v.begin(),v.end());
    v.erase(unique(v.begin(),v.end()),v.end());
    for(int i=1;i<=n;i++){
        int t=lower_bound(v.begin(),v.end(),a[i])-v.begin()+1;
        val[t]=a[i];
        a[i]=t;
        pos[a[i]].pb(i);
    }
    for(int i=1;i<=belong[n];i++){
        init(i);
    }
    for(int i=1;i<=n;i++){
        cin>>l>>r;
        cout<<val[query(l,r)]<<endl;
    }
    return 0;
}

原文地址：https://www.cnblogs.com/widsom/p/8413266.html

时间： 2024-08-30 13:38:12

算法笔记--数列分块的相关文章

数列分块入门

分块是莫队算法的前置知识,也是一种十分暴力的数据结构. 分块的核心思想是把要操作的数列 \(a_i\) 分成若干长度相等的"块":修改/查询时对于整一块都在指定区间 \([L,R]\) 内的块整体修改/查询,对于只有块的一部分在指定区间内的暴力修改/查询. 由于不需要操作/查询具有区间加法等性质,分块比线段树.树状数组.ST表等数据结构具有更加灵活的应用. 先来看一道例题数列分块入门 4,简而言之,就是要求实现区间加法&区间查询:线段树可以很轻松地实现这两个操作,

数列分块入门2 解题报告

题意概括区间加法,区间询问小于一个数的个数. 正题对于每个块,除原数组之外用一个vector来有序地存储所有数.当区间加时,对于每个完整块维护共同加数,对于不完整的块直接暴力加上再重新排序.当询问时,对于每个完整块在vector中二分,对于不完整的,直接暴力计数. 代码 #include<cstdio> #include<vector> #include<algorithm> #include<cmath> using namespace std; #d

算法笔记-DTW动态时间规整

算法笔记-DTW动态时间规整简介简单的例子定义讨论约束条件步模式标准化点与点的距离函数具体应用场景分类点到点匹配算法笔记-DTW动态时间规整动态时间规整/规划(Dynamic Time Warping, DTW)是一个比较老的算法,大概在1970年左右被提出来,最早用于处理语音方面识别分类的问题. 1.简介简单来说,给定两个离散的序列(实际上不一定要与时间有关),DTW能够衡量这两个序列的相似程度,或者说两个序列的距离.同时DTW能够对两个序列的延展或者压缩能够有一定

小算法笔记

素数: 除 1 外只能被 1 和自身整除的数. 方法一: #include <stdio.h> #define N 1000 int num = 0; int prime(int n) { int i; if(n % 2 == 0) return (n == 2); if(n % 3 == 0) return (n == 3); if(n % 5 == 0) return (n == 5); for(i = 7; i*i <= n; ++i) if(n % i == 0) return

算法笔记之堆排序

一.对堆排序的相关了解 1.堆排序的运行时间是 O(nlogn) : 2.定义: 堆heap是一棵具有以下属性的二叉树-- (1)它是一棵完全二叉树: (2)每个结点大于或等于它的任意一个孩子. 备注:完全二叉树的定义--除了最后一层没填满以及最后一层的叶子都是偏左放置的,其他层都是满的二叉树! 3.二叉堆有两种:最大堆和最小堆.在堆排序中我们使用的是最大堆,最小堆常常在构造优先队列时使用. 4.一条路径的深度指的是这条路径的边数,一个结点的深度是指从根结点到该结点的路径的长度. 二.对堆进行排

算法笔记_023:拓扑排序（Java）

目录 1 问题描述 2 解决方案 2.1 基于减治法实现 2.2 基于深度优先查找实现 1 问题描述给定一个有向图,求取此图的拓扑排序序列. 那么,何为拓扑排序? 定义:将有向图中的顶点以线性方式进行排序.即对于任何连接自顶点u到顶点v的有向边uv,在最后的排序结果中,顶点u总是在顶点v的前面. 2 解决方案 2.1 基于减治法实现实现原理:不断地做这样一件事,在余下的有向图中求取一个源(source)(PS:定义入度为0的顶点为有向图的源),它是一个没有输入边的顶点,然后把它和所有从它出发

算法笔记_018:旅行商问题（Java）

目录 1 问题描述 2 解决方案 2.1 蛮力法 1 问题描述何为旅行商问题?按照非专业的说法,这个问题要求找出一条n个给定的城市间的最短路径,使我们在回到触发的城市之前,对每个城市都只访问一次.这样该问题就可以表述为求一个图的最短哈密顿回路的问题.(哈密顿回路:定义为一个对图的每个顶点都只穿越一次的回路) 很容易看出来,哈密顿回路也可以定义为n+1个相邻顶点v1,v2,v3,...,vn,v1的一个序列.其中,序列的第一个顶点和最后一个顶点是相同的,而其它n-1个顶点都是互不相同的.并且

算法笔记1-最大子序列和问题的求解

问题-- 给定N个整数(有可能是负数)A1,A2,A3,A4...An,求最大子序列和. (子序列必须是连续的):比如,对于输入,-2,11,-4,13,-5,-2:这个序列, 答案是20,即从A2到A4. 对于这个问题,你怎么想的呢?下面有四种解法,看看你的解法是不是其中之一. 解法一.穷举解题思路-- 既然是求某一个连续的子序列的最大和,那么我们把所有的子序列的和都加一遍,然后用一个变量来存储最大的和值,当遍历一遍所有子序列,即可得到最大的和.由于这个子序列长度可以是1,也可以是N,因此需

[数据结构和算法]折半插入排序算法笔记

/// <summary> /// 步骤: /// 1.记录当前待排元素 /// 2.标记顺序表有序查找区域下界和上界 /// 3.在顺序表有序查找区域中折半查找等待排序元素的位置 /// 4.把顺序表有序查找区域的某些元素后移一位,以空出位置给等待排序的元素 /// 5.在空出的位置填写当前排序元素 /// </summary> /// <param name="elements"></param> static void SqList