蓝桥杯复习C++ --第一章_蓝桥杯c复习-优快云博客

本文链接：https://blog.youkuaiyun.com/Axerror/article/details/143492988

编程基础

#include<bits/stdc++.h>
--万能头文件

scanf("%[^\n]",s)
--s取直到\n才停止（正则表达式）

ios::sync_with_stdio(0);
--取消同步流，加速读写（sync意为同步）

cout<<fixed<<setprecision(x)<<a<<' '<<b<<endl;
--设置输出为x为小数

getline(cin,s);
--读取一整行储存到s中

str.substr(a,b)
--表示str中从a起长度为b的字符串

string str(buf);
--表示以字符串buf创建一个字符串str

str.length()
--返回str的长度

str.find("hello")
--返回str中hello的位置（不是地址）

str.append 或 +
--两个字符串相加

str1.replace(a,b,str2)
--str1中第a个字符起，长度为b的字符替换为str2

str1.compare(str2)
--比较str1和str2

for(auto i:s)
--依次复制s中的字符，i=s中的字符

for(auto &i:s)
--依次选中s中的字符，i=s中的地址，对s直接修改（引用类型）

-------------------------------------------------------------------------------
-
常用库函数

sort(a,a+n,*cmp)；
   bool cmp(int a,int b)return a>b；
--------快速排序，默认升序，
   时间复杂度为 n*log(n),会根据数组长度自动选择合适的排序方案
   a,a+n为排序开始，结尾的地址，
   cmp为比较函数（*表示可有可无）,返回a>b时为降序

sort(a,a+n,[](const int a,const int b)
{
    return a>b
})；

第三个函数为匿名函数，以上表示为降序排序

struct Node
{
    int u,v;
    bool operator <(const Node &m)const
    {
    //以u为第一关键字，v为第二关键字进行比较
    return u==m.u?v<m.v:u<m.u;
    }
}
//结构体小于号重载进行排序

min(),max()
--返回括号内最小，最大的值，可以丢一整个数组进去

min_element(begin,end)
max_element(begin,end)
--------begin表示起始查找地址，
   end表示结束查找地址，
   返回最大，最小值的地址
   时间复杂度为n;

nth_element(begin,target,end)
--------对begin到end位置进行排序，
target为目标位置目标位置以上均比target小，以下均比target大
排序后顺序不定

二分查找
vector<int> v={1，3，5，7，9}；
binary_search(v.begin(),v.end(),target)
--查找是否含有target在v中，返回bool值，数组顺序

lower_bound(v.begin,v.end,x);
upper_bound(v.begin,v.end,x);
--------前提数组为非降序
lower_bound返回x的下界的地址（第一个大于等于x的位置）
upper_bound返回x的上界的地址（第一个绝对大于x的位置）

-----！！！| \/ | \/ | \/ |重要的内容| \/ | \/ | \/ |！！！-----

int l=0 ,r=v.size()-1;
while(l+1<r)
{
    int mid = (l+r)/2;
    if(check(mid))l=mid;
    else r = mid;
}

--------手动二分查找，check为判断条件，可自主创建判断条件
原理为创建双指针，每次取中判断
根据结果需求取l,或r

-----！！！| /\ | /\ | /\ |重要的内容| /\ | /\ | /\ |！！！-----

islower(ch)
isupper(ch)
--判断为大写字母/判断为小写字母，不是字母为失败，返回类型为bool

tolower(ch)
toupper(ch)
--将ch转化为小写/大写字母，不是大写/小写则不进行操作

next_permutation(v.begin,v.end)
prev_permutation(v.begin,v.end)
--------按照字典顺序将v排序变为升序/降序排列的下一个
有bool返回值，当升序/降序未结束时返回1，结束时（已全排列时）返回0；
v为升序数组时，用while(next_permutation(v.begin,v.end))for(int num:v)cout<<num<<" ";cout<<endl;即可完成v的升序全排列

memset(ptr,value,num)
--ptr为设置值指针，value为设置值，num为设置字节数

swap(a,b)
---------a为第一个要交换值的引用，b为第二个要交换的值的引用
（就是直接输入swap(a,b)会对a,b的值直接进行互换）

reverse(BirderIt.begin,BirderIt.end)
--反转BirderIt（容器）中顺序

-------------------------------------------------------------------------------
STL
begin,end返回迭代器
front,back对应值

pair<int ,int > v(a,b)
--可通过v.first,v.second访问第一，第二个元素
--pair中可存放任意类型的数据
--pair仅可存放两个数据且不可扩展（如使用push()）

vector<int> v={};
--动态数组

last=unique(v.begin,v.end)；
v.erase(last,v.end)
--对v中连续的数进行去重，若为已排列的容器，则会去重，若为未排列的容器则会使该容器不出现连续重复的值,去重后重复元素将在不重复元素之后，并返回一个指向重复元素的迭代器,可通过erase去除

v.clear()
--清空容器
v.reset()
--重置容器（更常用）
list<>
--链表，不常用

set<int>
--集合（唯一互异)
基本函数
push_back()
push_front()
pop_back()
pop_front()
size()
empty()
clear()
front():返回第一个元素的引用（值）
back():返回最后一个元素的引用
begin():返回第一个元素的迭代器
end():返回末尾的下一个位置的迭代器
insert():在指定位置插入一个元素
erase():从链表中移除指定位置的一个或多个元素

stack<>
--栈，后进先出
基本函数
push()
pop()
top():返回顶部值但不出栈

queue<>
--队列，先进先出
基本函数
push()
pop()
front():返回队首元素
back()：返回对尾元素
empty()
size()：返回元素个数

-----！！！| \/ | \/ | \/ |重要的内容| \/ | \/ | \/ |！！！-----

#include<queue>
template <class T,class Container = vector<T>,
class Compare=less<typename Container::value_type>>
priority_queue;
--优先队列，也叫做堆，元素默认按从大到小排序

struct Compare{
    bool operator()(int a,int b){
    return a>b;
    }
}
int main(){
    std::priority_queue<int,std::vector<int>,compare> pq;
//修改元素排列顺序为从小到大（元素从大到小也叫大根堆，从小到大叫小根堆
}

priority_queue<int ,vector<int>,greater<int>> pq;
--修改简单数据排列顺序为从小到大
基本函数
push():插入，时间复杂度O(logN)
pop():弹出顶部元素，时间复杂度O(logN)
top()
empty()
size()

-----！！！| /\ | /\ | /\ |重要的内容| /\ | /\ | /\ |！！！-----

deque<>
--双端队列
基本函数
push_back()
push_front()
pop_back()
pop_front()
front()
back()

template<class Key ,class Compare = less<Key>,
class Allocator = allocator<key>>
set<>
--集合，储存唯一元素，默认升序，可通过修改compare更改顺序,同样，简单数据改降序可以用greater<Key>

multiset<>
--多重集合，允许存储重复元素，按一定规则排列

基本函数
insert()：O（log n）
erase()：移除指定元素，多重集合中会删除所有重复元素，可用erase(st.find(x))删除单个，时间复杂度O(log n)
find()

template <class Key ,class T, class Compare = less<Key>,
class Allocator = allocator<pair<const Key, T>>>
map<key,value>
--表，表示键与值的唯一映射关系，key对value有唯一的关系，key唯一,有初始顺序，按首键升序

multiset<>
--键与值映射关系不唯一，类似于set与multiset

unordered_map
--无序表

基本函数
first
second
insert({key,value}):时间复杂度O(log n)
insert(make_pair(key,value)):同上
erase(key)：删除元素，时间复杂度O(log n)
find(key):返回key的迭代器
count(key):返回元素个数，由于map中key对value唯一，所以用来判断元素是否存在
size():返回元素个数
lower_bound(x):返回x在key的下界
upper_bound(x):返回x在key的上界