ＳＴＬ模板-优快云博客

序列式容器

向量(vector) 连续存储的元素<vector>

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

双端队列(deque) 连续存储的指向不同元素的指针所组成的数组<deque>

适配器容器

栈(stack) 后进先出(LIFO)的值的排列 <stack>

队列(queue) 先进先出(FIFO)的值的排列 <queue>

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

关联式容器

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

多重集合(multiset) 允许存在两个次序相等的元素的集合 <set>

映射(map) 由{键，值}对组成的集合，以某种作用于键对上的谓词排列 <map>

多重映射(multimap) 允许键对有相等的次序的映射 <map>

1、Stack的常用用法

stack：栈，一个后进先出的容器。

1.1、stack的定义和构造类函数

1)加上头文件#include<stack>和using namespace std;

stack<typename> sk;

2) 构造类函数

缺省构造函数、拷贝构造函数、运算符构造函数

    #include<iostream>
    #include<stack>
    using namespace std;
    int main()
    {
        stack<int> s1;//构造函数
        s1.push(1);s1.push(2);s1.push(5);
        stack<int> s2(s1);
        stack<int> s3=s2;
        cout<<s3.top();
    }

1.2、stack容器元素的访问

stack是一种操作受限制的线性表，只能通过top()来访问栈顶元素。

#include<stdio.h>
#include<stack>

using namespace std;
int main()
{
    stack<int> sk;
    for(int i=1;i<=5;i++)
    {
        sk.push(i);//push(i)用来把i压入栈，入栈顺序1,2,3,4,5
    }
    printf("%d\n",sk.top());
    return 0;
}

1.3、stack常用函数

1.3.1、push()

push(x)：将x入栈，时间复杂度为O(1)

1.3.2、top()

top()：获取栈顶元素，时间复杂度为O(1)

1.3.3、pop()

pop()：出栈顶元素。

1.3.4、empty()

empty():判断栈是否为空

1.3.5、size()

size()：获得栈元素个数

#include<stdio.h>
#include<stack>

using namespace std;
int main()
{
    stack<int> sk;
    if(sk.empty()==true)printf("Empty\n");//判断栈空
    for(int i=1;i<=5;i++)
    {
        sk.push(i);//push(i)用来把i压入栈，入栈顺序1,2,3,4,5
    }
    printf("%d %d\n",sk.top(),sk.size());//5 5
    return 0;
}

1.4、stack的用途

用来模拟实现递归。程序的栈内存空间很小，如果用普通递归，可能会导致程序运行崩溃。

用栈模拟递归可以避免这种问题。

C++ 标准模板库STL 队列 queue 使用方法与应用介绍

queue

queue模板类的定义在<queue>头文件中。

与stack模板类很相似，queue模板类也需要两个模板参数，一个是元素类型，一个容器类型，元素类型是必要的，容器类型是可选的，默认为deque类型。

定义queue对象的示例代码如下：

queue<int> q1;

queue<double> q2;

queue的基本操作有：

入队，如例：q.push(x); 将x接到队列的末端。

出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。

访问队首元素，如例：q.front()，即最早被压入队列的元素。

访问队尾元素，如例：q.back()，即最后被压入队列的元素。

判断队列空，如例：q.empty()，当队列空时，返回true。

访问队列中的元素个数，如例：q.size()。

【c++】STL里的priority_queue用法总结

1、头文件

#include<queue>

2、定义

priority_queue<int> p;

3、优先输出大数据

priority_queue<Type, Container, Functional>

Type为数据类型， Container为保存数据的容器，Functional为元素比较方式。

如果不写后两个参数，那么容器默认用的是vector，比较方式默认用operator<，也就是优先队列是大顶堆，队头元素最大。

例如：

    #include<iostream>
    #include<queue>
    using namespace std;

    int main(){
       priority_queue<int> p;
       p.push(1);
       p.push(2);
       p.push(8);
       p.push(5);
       p.push(43);
       for(int i=0;i<5;i++){
           cout<<p.top()<<endl;
           p.pop();
       }
       return 0;
    }

输出：

4、优先输出小数据

方法一：

priority_queue<int, vector<int>, greater<int> > p;

例如：

    #include<iostream>
    #include<queue>
    using namespace std;

    int main(){
       priority_queue<int, vector<int>, greater<int> >p;
       p.push(1);
       p.push(2);
       p.push(8);
       p.push(5);
       p.push(43);
       for(int i=0;i<5;i++){
           cout<<p.top()<<endl;
           p.pop();
       }
       return 0;
    }

输出：

方法二：自定义优先级，重载默认的 < 符号

例子：

    #include<iostream>
    #include<queue>
    #include<cstdlib>
    using namespace std;
    struct Node{
       int x,y;
       Node(int a=0, int b=0):
           x(a), y(b) {}
    };

    struct cmp{
       bool operator()(Node a, Node b){
           if(a.x == b.x)   return a.y>b.y;
           return a.x>b.x;
       }
    };

    int main(){
       priority_queue<Node, vector<Node>, cmp>p;

       for(int i=0; i<10; ++i)
           p.push(Node(rand(), rand()));

       while(!p.empty()){
           cout<<p.top().x<<' '<<p.top().y<<endl;
           p.pop();
       }//while
       //getchar();
       return 0;
    }

输出：

代码测试：

//-----------------stl-------------------------------------------------------------------------------------------------
//-----------------------vector-------------------------------------------------------------------------------------
void vector_stl()
{
    vector <int> vcs;
    for (int i =0; i< 5; ++i) {
        vcs.push_back(i+1);
    }
    vector<int>::iterator k;
    for (k=vcs.begin(); k != vcs.end(); ++k) {
        //        printf("value=%d \n", *k);
    }
    k=vcs.begin();
    advance(k,2);               printf("k=%d \n", *k);

    vector<int>::reverse_iterator m = vcs.rbegin();
    /*printf("distance=%d \n", distance(k,m)); */
    //    cout<<"show "<<distance(k,m)<<endl;
    int l = 0;
    //    l = distance(k,m);
    printf("l=%d \n", l);
    iter_swap(k,m);      printf("value=%d, *M=%d \n", *k, *m);

    int nym[4] = {3, 4, 2, 1};
    sort(nym, nym+4);
    for (int i =0; i< 4; ++i) {
        cout<<"nym="<<nym[i];
    }

    //    for (m=vcs.rbegin(); m != vcs.rend(); ++m) {
    //        printf("value=%d \n", *m);
    //    }

    cout<<endl;
}
//------------------set------------------------------------------------------
void set_stl()
{
    multiset <int> set1;
    set1.insert(2);
    multiset<int>::iterator ii;
    ii=set1.begin();
    for (; ii != set1.end(); ++ii) {
        cout<<"i="<<*ii<<endl;
    }
    int shu = set1.count(2);   cout<<"shu="<<shu<<endl;

}
//----------------------map-------------------------------------------------------------------------
void mapfunc()
{
map <int , string> person;
pair <map<int, string>::iterator , bool> Insert_Pair;

Insert_Pair = person.insert(pair<int, string>(1,"xx"));
cout<<"1--------"<<Insert_Pair.second<<endl;

Insert_Pair = person.insert(pair<int, string>(1,"xx2"));
cout<<"2--------"<<Insert_Pair.second<<endl;

Insert_Pair = person.insert(map<int, string>::value_type(2,"haha"));
cout<<"3--------"<<Insert_Pair.second<<endl;

Insert_Pair = person.insert(map<int, string>::value_type(2,"haha2"));
cout<<"5--------"<<Insert_Pair.second<<endl;

person[3]="xiaoming";
person[4]="xiaohong";

    map<int,string>::iterator itr;
    for (itr= person.begin(); itr != person.end(); ++itr) {
        cout<<itr->first << "second="<<itr->second <<endl;
    }

int n = person.size(); cout<<"size="<<n<<endl;

    itr = person.find(2);
    if (itr != person.end()) {
        cout<<"find   "<<itr->second<<endl;
    } else {
        cout<<"not find" <<endl;
    }
    int ret = person.erase(3); cout<<"erase , ret="<<ret<<endl;

    for (itr= person.begin(); itr != person.end(); ++itr) {
        cout<<itr->first << "second="<<itr->second <<endl;
    }
    int count = person.count(5); cout<<"   count="<<count<<endl;

    person.erase(person.begin(), person.end());
}
//----------------stack--------------------------------------------------------------------------------------------
void stl_stack()
{
    stack <int> st; //缺省构造函数
    for (int i= 0; i< 5; ++i) {
        st.push(i);
    }
    // 拷贝构造函数、运算符构造函数
    stack <int> st2(st);
    stack <int> st3= st;

    st.pop();
    st.top();
    st.size();
    st.empty();

}
//------------------priority_deque--------------------------------------------------------------
struct Node {
    int x;
    int y;
    Node(int a=0, int b=0): x(a),y(b) {}
};
struct cmp {
    bool operator() (Node a, Node b) {
        if (a.x == b.x) return a.y > b.y;
        return a.x > b.x;
    }
};
//---------------------priority_deque---------------------------------------------------------------------------------------
void priority_deque()
{
    priority_queue <Node, vector<Node>,cmp> p;

// for(int i=0; i<10; ++i)
// p.push(Node(rand(),rand()));

        p.push(Node(2,12));
        p.push(Node(4,16));
        p.push(Node(6,29));
        p.push(Node(8,15));
        p.push(Node(1,5));
        p.push(Node(3,35));
        p.push(Node(5,8));

    while(!p.empty()){
        cout<<p.top().x<<' '<<p.top().y<<endl;
        p.pop();
    }//while
    //getchar();

}