语法基础之STL、位运算与库函数

• 1、vector
• 2、queue
• 3、栈
• 4、 deque
• 5、set
• 6、map
• 7、unordered_set
• 8、unordered_map
• 8、bitset
• 9、 pair
• 10、位运算
• 11、reverse
• 12、unique 去重
• 13、random_shuffle 随机 打乱
• 14、sort
• 15、lower_bound/upper_bound 二分
• 16、0到n-1中缺失的数字
• 17、调整数组顺序使奇数位于偶数前面
• 18、从尾到头打印链表
• 19、用两个栈实现队列
• 20、最小的k个数
• 21、和为S的两个数字（语法基础课）
• 22、数字排列
• 23、二进制中1的个数
• 24、三元组排序

可以自动改变数组长度
vector是变长数组，支持随机访问，不支持在任意位置O(1)插入。为了保证效率，元素的增删一般应该在末尾进行。

   声明
#include  	头文件
vector a;		相当于一个长度动态变化的int数组
vector b[233];	相当于第一维长233，第二位长度动态变化的
int数组
struct rec{…};
vector c;		自定义的结构体类型也可以保存在vector中

size/empty
size函数返回vector的实际长度（包含的元素个数），empty函数返回一个bool类型，表明vector是否为空。二者的时间复杂度都是O(1)。
所有的STL容器都支持这两个方法，含义也相同，之后我们就不再重复给出。

clear
clear函数把vector清空。

迭代器
迭代器就像STL容器的“指针”，可以用星号“*” *** 作符解除引用。
一个保存int的vector的迭代器声明方法为：
vector::iterator it;
vector的迭代器是“随机访问迭代器”，可以把vector的迭代器与一个
整数相加减，其行为和指针的移动类似。可以把vector的两个迭代器
相减，其结果也和指针相减类似，得到两个迭代器对应下标之间的距离。

begin/end
begin函数返回指向vector中第一个元素的迭代器。例如a是一个
非空的vector，则*a.begin()与a[0]的作用相同。
所有的容器都可以视作一个“前闭后开”的结构，end函数返回vector
的尾部，即第n个元素再往后的“边界”。*a.end()与a[n]都是越界访问
，其中n=a.size()。
下面两份代码都遍历了vectora，并输出它的所有元素。
for (int I = 0; I < a.size(); I ++) cout << a[i] << endl;
for (vector::iterator it = a.begin(); it != a.end(); it ++) 
cout << *it << endl;

front/back
front函数返回vector的第一个元素，等价于*a.begin() 和 a[0]。
back函数返回vector的最后一个元素，等价于 a[a.size() – 1]。

push_back() 和 pop_back()
a.push_back(x) 把元素x插入到vector a的尾部。
b.pop_back() 删除vector a的最后一个元素。

#include
#include
using namespace std;

int main()
{
  //声明
   vector a({1,2,3});
   //遍历
   for(int i=0;i::iterator i=a.begin();i!=a.end();i++)
   for(auto i=a.begin();i!=a.end();i++)
   cout<<*i<<" ";
   cout<
 
 
2、queue 
队列 、优先队列 、栈 没有clear函数。
 
#include
#include
using namespace std;

int main()
{
    queue q;//队列
    priority_queue a;//大根堆
    priority_queue,greater> b;
    //小根堆
    
    struct Rec 
    {
        int a,b;
        //大根堆
        bool operator <(const Rec& t) const
        {
            return a(const Rec& t) const
        {
            return a>t.a;
        }
    };
    priority_queue d;
    priority_queue,greater> e;
    d.push({1,2});
    e.push({1,2});
    //q是队列
    q.push(1);//队尾插入
    q.pop();//d出队头
    q.back();//返回队尾
    q=queue();//初始化或者清空队列
    //大根堆 a
    a.push();//插入
    a.top();//取最大值
    a.pop();//删除顶峰值
}
 
3、栈 

 插入 栈顶 取出。 先进后出。
 
4、 deque 

 双端队列deque是一个支持在两端高效插入或删除元素的连续线性存储空间。它就像是vector和queue的结合。与vector相比，deque在头部增删元素仅需要O(1)的时间；与queue相比，deque像数组一样支持随机访问。
 
[] 随机访问
 begin/end，返回deque的头/尾迭代器
 front/back 队头/队尾元素
 push_back 从队尾入队
 push_front 从队头入队
 pop_back 从队尾出队
 pop_front 从队头出队
 clear 清空队列
 
#include
#include
using namespace std;

int main()
{
    deque a;
    a.begin();
    a.end();
    a.front();
    a.back();
    a.push_back(2);
    a.push_front(1);
    a.pop_back();
    a.pop_front();
    a.clear();
    return 0;
}
 
5、set 
头文件set主要包括set和multiset两个容器，分别是“有序集合”和“有序多重集合”，即前者的元素不能重复，而后者可以包含若干个相等的元素。set和multiset的内部实现是一棵红黑树，它们支持的函数基本相同。
 
声明
set    s;
struct rec{…}; set s;	// 结构体rec中必须定义小于号
multiset s;

size/empty/clear
与vector类似

迭代器
set和multiset的迭代器称为“双向访问迭代器”，不支持“随机访问”，支持
星号(*)解除引用，仅支持”++”和--“两个与算术相关的 *** 作。
设it是一个迭代器，例如set::iterator it;
若把it++，则it会指向“下一个”元素。这里的“下一个”元素是指在元素从小
到大排序的结果中，排在it下一名的元素。同理，若把it--，则it将会指向
排在“上一个”的元素。

begin/end
返回集合的首、尾迭代器，时间复杂度均为O(1)。
s.begin() 是指向集合中最小元素的迭代器。
s.end() 是指向集合中最大元素的下一个位置的迭代器。
换言之，就像vector一样，是一个“前闭后开”的形式。因此--s.end()是指向集合中最大元素的迭代器。

insert
s.insert(x)把一个元素x插入到集合s中，时间复杂度为O(logn)。
在set中，若元素已存在，则不会重复插入该元素，对集合的状态无影响。

find
s.find(x) 在集合s中查找等于x的元素，并返回指向该元素的迭代器。若不存在，则返回s.end()。时间复杂度为O(logn)。

lower_bound/upper_bound
	这两个函数的用法与find类似，但查找的条件略有不同，时间复杂度为 O(logn)。
s.lower_bound(x) 查找大于等于x的元素中最小的一个，并返回指向该元素的迭代器。
s.upper_bound(x) 查找大于x的元素中最小的一个，并返回指向该元素的迭代器。

erase
设it是一个迭代器，s.erase(it) 从s中删除迭代器it指向的元素，时间复杂度为O(logn)
设x是一个元素，s.erase(x) 从s中删除所有等于x的元素，时间复杂度为O(k+logn)，其中k是被删除的元素个数。

count
s.count(x) 返回集合s中等于x的元素个数，时间复杂度为 O(k +logn)，其中k为元素x的个数。

 
#include
#include
using namespace std;

int main()
{
    set a;//元素不能重复
    multiset b;//元素可以重复
    struct Rec
    {
        int x,y;
        bool operator <(const Rec& t) const
        {
            return x c;
    
    auto it=a.begin();
    it++;
    it--;
    ++it;
    --it;
    a.end();
    a.insert(1);
    int x;
    //判断x在a中是否存在
    if(a.find(x)==a.end()){}
    //二分
    a.lower_bound(x);
    //找到大于等于x的最小的元素的迭代器
    a.upper_bound(x);
    //找到大于x的最小的元素的迭代器
    
    a.erase(it);
    a.count(x);//x的个数  
}
 
6、map 
map容器是一个键值对key-value的映射，其内部实现是一棵以key为关键码
的红黑树。Map的key和value可以是任意类型，其中key必须定义小于号运算
符。

声明
		map name;
		例如：
		map vis;
		map hash;
		map, vector> test;

size/empty/clear/begin/end均与set类似。

Insert/erase
与set类似，但其参数均是pair。

find
h.find(x) 在变量名为h的map中查找key为x的二元组。

[] *** 作符
h[key] 返回key映射的value的引用，时间复杂度为O(logn)。	
[] *** 作符是map最吸引人的地方。我们可以很方便地通过h[key]来得到key对
应的value，还可以对h[key]进行赋值 *** 作，改变key对应的value。

 
#include
#include