STL 整理1（map、set、vector、list、stack、queue、deque、priority_queue）

向量(vector) <vector>

连续存储的元素<vector>

Vector<int>c;

c.back()    传回最后一个数据，不检查这个数据是否存在。

c.clear()     移除容器中所有数据。

c.empty()   判断容器是否为空。

c.front()     传回地一个数据。

c.pop_back() 删除最后一个数据。

c.push_back(elem)  在尾部加入一个数据。

c[i] 等同于 c.at(i);

列表(list) <list>

由节点组成的双向链表，每个结点包含着一个元素<list>

list<int> list1(1,2,3)

front()返回第一个元素的引用  int nRet =list1.front()    // nRet = 1

back()返回最后一元素的引用  int nRet =list1.back()     // nRet = 3

push_back()增加一元素到链表尾 list1.push_back(4)       //list1(1,2,3,4)

push_front()增加一元素到链表头  list1.push_front(4)      //list1(4,1,2,3)

pop_back()删除链表尾的一个元素 list1.pop_back()          //list1(1,2)

pop_front()删除链表头的一元素  list1.pop_front()　         //list1(2,3)

clear()删除所有元素   list1.clear();   // list1空了,list1.size()=0

sort()对链表排序，默认升序(可自定义回调函数) 

list对象L1(4,3,5,1,4)  L1.sort();                

 //L1(1,3,4,4,5) L1.sort(greater<int>()); 

//L1(5,4,4,3,1)

insert()在指定位置插入一个或多个元素

list1.insert(++list1.begin(),9);  // list1(1,9,2,3)

list1.insert(list1.begin(),2,9);  // list1(9,9,1,2,3);

list1.insert(list1.begin(),list2.begin(),--list2.end());//list1(4,5,1,2,3);

swap()交换两个链表(两个重载)

list1.swap(list2);   //list1（4，5，6） list2（1，2，3）

unique()删除相邻重复元素

L1(1,1,4,3,5,1)

L1.unique();// L1(1,4,3,5,1)

merge()合并两个有序链表并使之有序

// 升序list1.merge(list2);          //list1(1,2,3,4,5,6) list2现为空

// 降序L1(3,2,1), L2(6,5,4)L1.merge(L2, greater<int>()); //list1(6,5,4,3,2,1) list2现为空

reverse()反转链表:list1.reverse();     //list1(3,2,1)

remove()删除链表中匹配值的元素(匹配元素全部删除)list对象L1(4,3,5,1,4)L1.remove(4);               //L1(3,5,1);

empty()判断是否链表为空bool bRet =L1.empty(); //若L1为空，bRet = true，否则bRet = false。

rbegin()返回链表最后一元素的后向指针(reverse_iteratoror const)list<int>::reverse_iterator it = list1.rbegin();  //*it = 3

rend()返回链表第一元素的下一位置的后向指针list<int>::reverse_iteratorit = list1.rend(); // *(--riter) = 1

 

集合(set) <set>

由节点组成的红黑树，每个节点都包含着一个元素，节点之间以某种作用于元素对的谓词排列，没有两个不同的元素能够拥有相同的次序 <set>

set<type>: 以less<>为排序法则的set

set<type,op>: 以op为排序法则的set

struct op{

    bool operator()(const rec&a,const rec&b){

        return a.x<b.x||a.x==b.x&&a.y<b.y;

    }

};

1.1 set：：begin

功能：返回第一个元素的定位器（iterator）的地址。

set <char>：：iterator cp;

ctr.insert（'a'）;

ctr.insert（'b'）;

cp=ctr.begin（）; //定位到ctr 的开始位置

1.2 set：：clear

功能：将一个set 容器的全部元素删除。

1.3 set：：count

功能：返回对应某个关键字的元素的个数。好像都是1吧

1.4 set：：empty

功能：测试一个set 容器是否为空。

1.5 set：：end

功能：返回最后一个元素后面的定位器（iterator）的地址。

1.7 set：：erase

功能：将一个或一定范围的元素删除。

1.8 set：：find

功能：求出与给定的关键字相等的元素的定位器。

set <string> ctr;

    ctr.insert("abc");

    ctr.insert("abcd");

    ctr.insert("abcf");

    set <string>::iterator cp;

    cp=ctr.find("abc"); //查找key=1 的元素

    if(cp!=ctr.end())

        cout<<*cp <<endl;//显示abc

    cp=ctr.find("adf"); //查找key=2 的元素

    if(cp!=ctr.end())

        cout<<*cp <<endl;//不显示

    cp=ctr.find("gfv"); //查找key=3 的元素

    if(cp!=ctr.end())

        cout<<*cp <<endl;// 不显示

1.10 set：：insert

功能：将一个元素或者一定数量的元素插入到set 的特定位置中。

1.25 set：：upper_bound

功能：求出指向第一个关键字的值是大于一个给定值的元素的定位器。

cp=ctr.upper_bound（2）;//输出比2大的最小元素

多重集合(multiset)< set>

允许存在两个次序相等的元素的集合 <set>

multiset<type>: 以less<>为排序法则的multiset

multiset<type, op>: 以op为排序法则的multise

struct op{

bool operator()(const rec&a,const rec&b){

        return a.x<b.x||a.x==b.x&&a.y<b.y;

    }

};

multiset<int>h;

__typeof(h.begin()) c=h.begin();//c指向h序列中第一个元素的地址，第一个元素是最小的元素

printf("%d ",*c);//将地址c存的数据输出

h.erase(c);//从h序列中将c指向的元素删除

__typeof()是个好东西~

栈(stack)  <stack>

后进先出的值的排列 <stack>

定义一个stack的变量stack<int> s;

入栈，如例：s.push(x);

出栈，如例：s.pop();注意，出栈操作只是删除栈顶元素，并不返回该元素。

访问栈顶，如例：s.top()

判断栈空，如例：s.empty()，当栈空时，返回true。

访问栈中的元素个数，如例：s.size()

队列(queue) <queue>

先进先出的执的排列 <queue>

定义一个queue的变量     queue<Type> M
查看是否为空范例        M.empty()   是的话返回1，不是返回0;
从已有元素后面增加元素M.push()
输出现有元素的个数        M.size()
显示第一个元素              M.front()
显示最后一个元素           M.back()
清除第一个元素              M.pop()

优先队列(priority_queue) <queue>

元素的次序是由作用于所存储的值对上的某种谓词决定的的一种队列 <queue>

1、默认从大到小

priority_queue<int> qi;

2、从小到大输出可以传入一个比较函数，使用functional.h函数对象作为比较函数，great<int>(小到大) less<int>(大到小)

priority_queue<int, vector<int>, greater<int> >qi2; 第二个参数为容器类型。第三个参数为比较函数。

3、自定义：

struct cmp  // 最小优先队列

{

    bool operator()(const long long i,constlong long j)

    {

        return i>j;

    }

};

priority_queue<int,vector<longlong>,cmp> Q;

 

 

struct node // 最小优先队列

{

    int id,len;

    bool operator < (const node &b)const// 只能重载小于号

    {

        return len>b.len;

    }

};

priority_queue<node>Q;

 

Q.empty() // 判断队列是否为空返回ture表示空返回false表示空 bool

Q.top() // 返回顶端元素的值元素还在队列里

Q.pop() // 删除顶端元素 void

Q.push(V) // 把long long型的数V加入到队列里它会制动条件V的位置void

Q.size() // 返回队列里元素个数 unsigned int

双端队列(deque) <deque>

连续存储的指向不同元素的指针所组成的数组<deque>

deque<int>c

c.pop_back()      删除最后一个数据。

c.pop_front()      删除头部数据。

c.push_back(elem) 在尾部加入一个数据。

c.push_front(elem) 在头部插入一个数据。

c.clear()          移除容器中所有数据。

c.front()          传回地一个数据。

c.back()          传回最后一个数据，不检查这个数据是否存在。

c.size()           返回容器中实际数据的个数。

c.empty()         判断容器是否为空。

c[i] 等同于 c.at(i);