功能：
- 已重载[]运算符
- 已重载+运算符（合并）
- 已重载+=运算符
- 已重载构造函数
- clear()
- it() 以std::vector形式返回自身
- print(char=' ',char='\n') 输出，第一个参数为分隔符，第二个参数为结束符
- count(x) 查找x的出现次数
- find(x) 判断x是否出现，是返回1，否则返回0
- empty() 判断当前是否为空
- size() 返回当前元素个数
- lower_bound(x) 查找第一个大于等于x的位置，返回其下标
- upper_bound(x) 查找第一个大于x的位置，返回其下标
- insert(x) 插入一个元素x
- remove(x) 删除一个等于x的元素，未找到则不执行
- remove_all(x) 删除所有等于x的元素
- remove_smaller(x,bool=false) 删除全部小于x的元素 (bool=true 时为小于等于)
- remove_larger(x,bool=false) 删除全部大于x的元素 (bool=true 时为大于等于)
- findpre(x) 寻找小于x的最近元素，返回其下标，或者返回-1
- findnext(x) 寻找大于x的最近元素，返回其下标，或者返回-1
- nearestabs(x) 寻找x与当前所有元素之差的最小值，不存在则返回0
- remove_nearestabs(x) 寻找x与当前所有元素之差的最小值，并将其删除，不存在则返回0
- locate_nearestabs(x) 寻找x与当前所有元素之差的最小值，返回其下标，或者返回-1
- find_maxnum(x) 寻找第x大的数，返回其值，或者返回-1
- find_minnum(x) 寻找第x小的数，返回其值，或者返回-1
定义:
ordered_vector<int> a;
ordered_vector<int> b();
ordered_vector<int> c({1,2,3,3,4,5,6,7});
ordered_vector<int> d({});
std::vector<int> s{1,2,3,4,5};
ordered_vector<int> d(s);
代码:
#include<bits/stdc++.h>
using namespace std;
namespace hdk{
template<typename T>
class ordered_vector{
private:
std::vector<T>v;
inline void push_back(T x){
v.push_back(x);
}
public:
ordered_vector(vector<T> x={}){
v=x;
}
inline void clear(){
v.clear();
}
inline int lower_bound(T x){
int loc=std::lower_bound(v.begin(),v.end(),x)-v.begin();
return loc;
}
inline int upper_bound(T x){
int loc=std::upper_bound(v.begin(),v.end(),x)-v.begin();
return loc;
}
inline void insert(T x){
v.insert(v.begin()+lower_bound(x),x);
}
inline void remove(T x){
int pos=lower_bound(x);
if(pos!=v.size() and v[pos]==x) v.erase(v.begin()+pos);
}
inline void remove_all(T x){
while(1){
int pos=lower_bound(x);
if(pos==v.size()) break;
if(v[pos]!=x) break;
v.erase(v.begin()+pos);
}
}
inline std::vector<T> it(){
return v;
}
T operator [](int x){
if(x==-1) return -1;
return v[x];
}
inline void remove_larger(int x,bool include_this=false){
int pos=upper_bound(x);
for(int i=v.size()-1;i>=pos;--i){
v.erase(v.begin()+i);
}
if(include_this) remove_all(x);
}
inline void print(char devide=' ',char ending='\n'){
for(T i:v) cout<<i<<devide;
cout<<ending;
}
inline void remove_smaller(int x,bool include_this=false){
int pos=lower_bound(x);
for(int i=pos-1;i>=0;--i){
v.erase(v.begin()+i);
}
if(include_this) remove_all(x);
}
inline int findpre(T x){
int pos=lower_bound(x)-1;
if(pos<0) return -1;
return pos;
}
inline int findnext(T x){
int pos=upper_bound(x);
if(pos>=v.size()) return -1;
return pos;
}
inline T nearestabs(T x){
int p=findpre(x),n=findnext(x),ans=0x7fffffff;
if(p>=0) ans=min(ans,x-v[p]);
if(n>=0) ans=min(ans,v[n]-x);
return ans;
}
inline T remove_nearestabs(T x){
if(v.empty()) return 0;
int p=findpre(x),n=findnext(x),ans=0x7fffffff;bool isp=0;
if(p>=0) if(x-v[p]<ans) ans=x-v[p],isp=1;
if(n>=0) if(v[n]-x<ans) ans=v[n]-x,isp=0;
if(isp) v.erase(v.begin()+p);
else v.erase(v.begin()+n);
return ans;
}
inline int locate_nearestabs(T x){
if(v.empty()) return -1;
int p=findpre(x),n=findnext(x),ans=0x7fffffff;bool isp=0;
if(p>=0) if(x-v[p]<ans) ans=x-v[p],isp=1;
if(n>=0) if(v[n]-x<ans) ans=v[n]-x,isp=0;
if(isp) return p;
else return n;
}
inline int count(T x){
int b=lower_bound(x),e=upper_bound(x);
return e-b;
}
inline bool find(T x){
return count(x);
}
inline bool empty(){
return v.empty();
}
inline int size(){
return v.size();
}
inline int find_maxnum(int rank){
if(rank>v.size() or rank<1) return -1;
return v[v.size()-rank];
}
inline int find_minnum(int rank){
if(rank>v.size() or rank<1) return -1;
return v[rank-1];
}
ordered_vector<T> operator +(ordered_vector<T> x){
ordered_vector<T> ans;
int i=0,j=0;
while(i<size() and j<x.size()){
if(v[i]<x[j]){
ans.push_back(v[i]);
i++;
}
else{
ans.push_back(x[j]);
j++;
}
}
while(i<size()){
ans.push_back(v[i]);
i++;
}
while(j<x.size()){
ans.push_back(x[j]);
j++;
}
return ans;
}
void operator +=(ordered_vector<T> x){
*this=(*this)+x;
}
};
}
using namespace hdk;
