C++标准库中封装的一些数据结构

向量(vector)

#include <vector>

1.构造函数
vector():创建一个空vector
vector(int nSize):创建一个vector,元素个数为nSize
vector(int nSize,const t& t):创建一个vector，元素个数为nSize,且值均为t
vector(const vector&):复制构造函数
vector(begin,end):复制[begin,end)区间内另一个数组的元素到vector中
2.增加函数
void push_back(const T& x):向量尾部增加一个元素X
iterator insert(iterator it,const T& x):向量中迭代器指向元素前增加一个元素x
iterator insert(iterator it,int n,const T& x):向量中迭代器指向元素前增加n个相同的元素x
iterator insert(iterator it,const_iterator first,const_iterator last):向量中迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据
3.删除函数
iterator erase(iterator it):删除向量中迭代器指向元素
iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
void pop_back():删除向量中最后一个元素
void clear():清空向量中所有元素
4.遍历函数
reference at(int pos):返回pos位置元素的引用
reference front():返回首元素的引用
reference back():返回尾元素的引用
iterator begin():返回向量头指针，指向第一个元素
iterator end():返回向量尾指针，指向向量最后一个元素的下一个位置
reverse_iterator rbegin():反向迭代器，指向最后一个元素
reverse_iterator rend():反向迭代器，指向第一个元素之前的位置
5.判断函数
bool empty() const:判断向量是否为空，若为空，则向量中无元素
6.大小函数
int size() const:返回向量中元素的个数
int capacity() const:返回当前向量张红所能容纳的最大元素值
int max_size() const:返回最大可允许的vector元素数量值
7.其他函数
void swap(vector&):交换两个同类型向量的数据
void assign(int n,const T& x):设置向量中第n个元素的值为x
void assign(const_iterator first,const_iterator last):向量中[first,last)中元素设置成当前向量元素

/*一维*/
#include <string.h>
#include <vector>
#include <iostream>
using namespace std;
 
int main()
{
    vector<int>obj;                    //创建一个向量存储容器 int
    for(int i=0;i<10;i++){             // push_back(elem)在数组最后添加数据 
        obj.push_back(i);
        cout<<obj[i]<<",";    
    }
    for(int i=0;i<5;i++){              //去掉数组最后一个数据 
        obj.pop_back();
    }
    cout<<"\n"<<endl;
    for(int i=0;i<obj.size();i++){      //size()容器中实际数据个数
        cout<<obj[i]<<",";
    }
    return 0;
}

/********************************************************
运行结果：

0,1,2,3,4,5,6,7,8,9,

0,1,2,3,4,
********************************************************/

/*二维*/
#include <string.h>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
    int N=5, M=6;
    //vector<vector<int> > obj(N, vector<int>(M)); //定义二维动态数组5行6列
    vector<vector<int> > obj(N); //定义二维动态数组大小5行
    for(int i =0; i< obj.size(); i++)//动态二维数组为5行6列，值全为0
    {
        obj[i].resize(M);
    }

    for(int i=0; i< obj.size(); i++)//输出二维动态数组
    {
        for(int j=0;j<obj[i].size();j++)
        {
            cout<<obj[i][j]<<" ";
        }
        cout<<"\n";
    }
    return 0;
}
/********************************************************
运行结果：

0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
********************************************************/

---------------------------------------------------------------------------------------------------------------------------

栈(stack)

#include <stack>

top()：返回一个栈顶元素的引用，类型为 T&。如果栈为空，返回值未定义。
push(const T& obj)：可以将对象副本压入栈顶。这是通过调用底层容器的 push_back() 函数完成的。
push(T&& obj)：以移动对象的方式将对象压入栈顶。这是通过调用底层容器的有右值引用参数的 push_back() 函数完成的。
pop()：弹出栈顶元素。
size()：返回栈中元素的个数。
empty()：在栈中没有元素的情况下返回 true。
emplace()：用传入的参数调用构造函数，在栈顶生成对象。
swap(stack<T> & other_stack)：将当前栈中的元素和参数中的元素交换。参数所包含元素的类型必须和当前栈的相同。对于 stack 对象有一个特例化的全局函数 swap() 可以使用。

#include <string.h>
#include <stack>
#include <iostream>
using namespace std;

int main()
{
    stack<int> s;                     //创建一个int型的栈
    for(int i=0;i<10;i++)             // 数据压栈
    {
        s.push(i);
    }
cout <<"栈中元素个数："<<s.size()<<endl;
    while(!s.empty()){                //判栈空
        cout << s.top()<<" ";         //取栈顶
        s.pop();                      //出栈
    }
    return 0;
}

/********************************************************
运行结果：

栈中元素个数：10
9 8 7 6 5 4 3 2 1 0
********************************************************/

---------------------------------------------------------------------------------------------------------------------------

队列(queue)

#include <queue>

front()：返回 queue 中第一个元素的引用。如果 queue 是常量，就返回一个常引用；如果 queue 为空，返回值是未定义的。
back()：返回 queue 中最后一个元素的引用。如果 queue 是常量，就返回一个常引用；如果 queue 为空，返回值是未定义的。
push(const T& obj)：在 queue 的尾部添加一个元素的副本。这是通过调用底层容器的成员函数 push_back() 来完成的。
push(T&& obj)：以移动的方式在 queue 的尾部添加元素。这是通过调用底层容器的具有右值引用参数的成员函数 push_back() 来完成的。
pop()：删除 queue 中的第一个元素。
size()：返回 queue 中元素的个数。
empty()：如果 queue 中没有元素的话，返回 true。
emplace()：用传给 emplace() 的参数调用 T 的构造函数，在 queue 的尾部生成对象。
swap(queue<T> &other_q)：将当前 queue 中的元素和参数 queue 中的元素交换。它们需要包含相同类型的元素。也可以调用全局函数模板 swap() 来完成同样的操作。

#include <string.h>
#include <queue>
#include <iostream>
using namespace std;

int main()
{
    queue<int> q;                       //创建一个int型的队列
    for(int i=0;i<10;i++)               // 数据入队
    {
        q.push(i);
    }
    cout <<"队列元素个数："<<q.size()<<endl;
    while(!q.empty()){                  //判队空
        cout << q.front()<<" ";         //取队首
        q.pop();                        //出队
    }
    return 0;
}

/********************************************************
运行结果：

队列元素个数：10
0 1 2 3 4 5 6 7 8 9
********************************************************/

---------------------------------------------------------------------------------------------------------------------------

优先级队列(priority_queue)

#include <priority_queue>

push(const T& obj)：将obj的副本放到容器的适当位置，这通常会包含一个排序操作。
push(T&& obj)：将obj放到容器的适当位置，这通常会包含一个排序操作。
emplace(T constructor a rgs...)：通过调用传入参数的构造函数，在序列的适当位置构造一个T对象。为了维持优先顺序，通常需要一个排序操作。
top()：返回优先级队列中第一个元素的引用。
pop()：移除第一个元素。
size()：返回队列中元素的个数。
empty()：如果队列为空的话，返回true。
swap(priority_queue<T>& other)：和参数的元素进行交换，所包含对象的类型必须相同。

#include<stdio.h>
#include<iostream>
#include<queue>
using namespace std;
//定义结构，使用运算符重载,自定义优先级1
struct cmp1{
    bool operator ()(int &a,int &b){
        return a>b;//最小值优先
    }
};
struct cmp2{
    bool operator ()(int &a,int &b){
        return a<b;//最大值优先
    }
};
//定义结构，使用运算符重载,自定义优先级2
struct number1{
    int x;
    bool operator < (const number1 &a) const {
        return x>a.x;//最小值优先
    }
};
struct number2{
    int x;
    bool operator < (const number2 &a) const {
        return x<a.x;//最大值优先
    }
};
int arr[]={1,2,3,6,5,4,10,13,15,16,14,12};
number1 num1[]={1,2,3,6,5,4,10,13,15,16,14,12};
number2 num2[]={1,2,3,6,5,4,10,13,15,16,14,12};

int main()
{   priority_queue<int>que0;//采用默认优先级构造队列

    priority_queue<int,vector<int>,cmp1>que1;//最小值优先
    priority_queue<int,vector<int>,cmp2>que2;//最大值优先

    priority_queue<int,vector<int>,greater<int> >que3;//注意“>>”会被认为错误，
                                                      //这是右移运算符，所以这里用空格号隔开
    priority_queue<int,vector<int>,less<int> >que4;最大值优先

    priority_queue<number1>que5;
    priority_queue<number2>que6;

    int i;
    for(i=0;arr[i];i++){
        que0.push(arr[i]);
        que1.push(arr[i]);
        que2.push(arr[i]);
        que3.push(arr[i]);
        que4.push(arr[i]);
    }
    for(i=0;num1[i].x;i++)
        que5.push(num1[i]);
    for(i=0;num2[i].x;i++)
        que6.push(num2[i]);


    cout<<"采用默认优先关系:\n定义(priority_queue<int>que;)\n"<<"Queue 0:\n";
    while(!que0.empty()){
        cout<<que0.top()<<" ";
        que0.pop();
    }
    cout<<endl<<endl;
    cout<<"采用结构体自定义优先级方式一:\n定义(priority_queue<int,vector<int>,cmp>que;)\n"<<"Queue 1:\n";
    while(!que1.empty()){
        cout<<que1.top()<<" ";
        que1.pop();
    }
    cout<<endl<<"Queue 2:\n";
    while(!que2.empty()){
        cout<<que2.top()<<" ";
        que2.pop();
    }
    cout<<endl<<endl;
    cout<<"采用头文件\"functional\"内定义优先级:\n定义(priority_queue<int,vector<int>,greater<int>/less<int> >que;)\n"<<"Queue 3:\n";
    while(!que3.empty()){
        cout<<que3.top()<<" ";
        que3.pop();
    }
    cout<<endl<<"Queue 4:\n";
    while(!que4.empty()){
        cout<<que4.top()<<" ";
        que4.pop();
    }
    cout<<endl<<endl;
    cout<<"采用结构体自定义优先级方式二:\n定义(priority_queue<number>que)\n"<<"Queue 5:\n";
    while(!que5.empty()){
        printf("%d ",que5.top());
        que5.pop();
    }
    cout<<endl<<"Queue 6:\n";
    while(!que6.empty()){
        printf("%d ",que6.top());
        que6.pop();
    }
    cout<<endl;
    return 0;
}


/********************************************************
运行结果：

采用默认优先关系:
定义(priority_queue<int>que;)
Queue 0:
16 15 14 13 12 10 6 5 4 3 2 1

采用结构体自定义优先级方式一:
定义(priority_queue<int,vector<int>,cmp>que;)
Queue 1:
1 2 3 4 5 6 10 12 13 14 15 16
Queue 2:
16 15 14 13 12 10 6 5 4 3 2 1

采用头文件"functional"内定义优先级:
定义(priority_queue<int,vector<int>,greater<int>/less<int> >que;)
Queue 3:
1 2 3 4 5 6 10 12 13 14 15 16
Queue 4:
16 15 14 13 12 10 6 5 4 3 2 1

采用结构体自定义优先级方式二:
定义(priority_queue<number>que)
Queue 5:
1 2 3 4 5 6 10 12 13 14 15 16
Queue 6:
16 15 14 13 12 10 6 5 4 3 2 1
********************************************************/

---------------------------------------------------------------------------------------------------------------------------

集合(set)

#include <set>

begin()     　　     ,返回set容器的第一个元素
end() 　　　　     ,返回set容器的最后一个元素
erase(data)         ,删除set容器中的data元素
clear()   　　         ,删除set容器中的所有的元素
empty() 　　　    ,判断set容器是否为空
max_size() 　     ,返回set容器可能包含的元素最大个数
size() 　　　　     ,返回当前set容器中的元素个数
rbegin　　　　     ,返回的值和end()相同
rend()　　　　     ,返回的值和rbegin()相同
upper_bound(data)    ,返回大于某个值元素的迭代器
lower_bound(data)    ,返回指向大于（或等于）某值的第一个元素的迭代器
find(data)        ,返回一个指向被查找到元素的迭代器
count(data)    ,判断元素data是否在集合中出现

#include<set>
#include<iostream>
using namespace std;
int main()
{
    set<int>s;
    int arr[10]={1,2,3,4,4,3,0,9,7,5};
    for(int i=0;i<10;i++)
    {
        s.insert (arr[i]);
    }
    s.erase(7);         //删除元素7
    cout<<"set 中 4 出现的次数是 ："<<s.count(4)<<endl;
    cout<<"set 中 10 出现的次数是 ："<<s.count(10)<<endl;
    cout<<"set: ";
    set<int>::iterator it;
    for(it=s.begin ();it!=s.end ();it++)
    {
        printf("%d ",*it);
    }
    cout << endl;

    //s.end()没有值
    cout<<"s.begain()[第一个元素]："<<*s.begin ()<<endl;
    //lower_bound()--返回指向大于（或等于）某值的第一个元素的迭代器
    cout<<"lower_buond[返回大于等于3的一个元素]："<<*s.lower_bound (3)<<endl;

    //upper_bound()--返回大于某个值元素的迭代器
    cout<<"upper_bound[返回大于3的一个元素]："<<*s.upper_bound (3)<<endl;

    //find()--返回一个指向被查找到元素的迭代器
    cout<<"find()[元素3所在位置]："<<*s.find (3)<<endl;

    cout<<"s.size()[元素个数]："<<s.size ()<<endl;
    return 0;
}
/********************************************************
运行结果：

set 中 4 出现的次数是 ：1
set 中 10 出现的次数是 ：0
set: 0 1 2 3 4 5 9
s.begain()[第一个元素]：0
lower_buond[返回大于等于3的一个元素]：3
upper_bound[返回大于3的一个元素]：4
find()[元素3所在位置]：3
s.size()[元素个数]：7
********************************************************/

---------------------------------------------------------------------------------------------------------------------------

pair

(将2个数据组合成一组数据)

#include <iostream>
#include <string>
#include <vector>
using namespace std;
//将pair放入容器&initpair
int main(int argc, const char *argv[])
{
    vector<pair<string, int> > vec;//初始化vector

    pair<string, int> p1;//num.1
    p1.first = "hello";
    p1.second = 12 ;
    vec.push_back(p1);

    pair<string, int> p2("world", 22);//num.2
    vec.push_back(p2);

    vec.push_back(make_pair<string, int>("foo", 44));//num.3

    for(vector<pair<string,int> >::iterator it = vec.begin(); //g++ main.cc -std=c++0x
        it != vec.end();
        ++it)
    {
        cout << "first: " << it->first << "  second:"<< it->second << endl;
    }

    return 0;
}

/********************************************************
运行结果：

first: hello  second:12
first: world  second:22
first: foo  second:44
********************************************************/

---------------------------------------------------------------------------------------------------------------------------

映射(map)

#include <map>

begin()        返回指向map头部的迭代器
clear(）        删除所有元素
count()        返回指定元素出现的次数
empty()        如果map为空则返回true
end()        返回指向map末尾的迭代器
equal_range()    返回特殊条目的迭代器对
erase()        删除一个元素
find()        查找一个元素
get_allocator()    返回map的配置器
insert()        插入元素
key_comp()    返回比较元素key的函数
lower_bound()    返回键值>=给定元素的第一个位置
max_size()    返回可以容纳的最大元素个数
rbegin()        返回一个指向map尾部的逆向迭代器
rend()        返回一个指向map头部的逆向迭代器
size()        返回map中元素的个数
swap()        交换两个map
upper_bound()    返回键值>给定元素的第一个位置
value_comp()    返回比较元素value的函数

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

int main()
{
    map<int, string> mapStudent;
    mapStudent.insert(pair<int, string>(1, "student_1"));
    mapStudent[2] = "student_2";
    mapStudent[3] = "student_3";
    for(int i=4;i<10;i++)
        mapStudent[i] = "student..";
    mapStudent[3] = "student__";       //修改
    map<int, string>::iterator it;
    it = mapStudent.begin();
    while(it != mapStudent.end())
    {
    cout<<it->first<<" : "<<it->second<<endl;
    it ++;
    }
    cout<<"当前map元素个数："<<mapStudent.size()<<endl;
    it = mapStudent.find(1);

    if(it != mapStudent.end())
        cout<<"该元素为"<<it->second<<endl;
    else
        cout<<"没有找到该元素"<<endl;
    if(mapStudent.erase(1))
        cout <<"删除成功"<<endl;
    else
        cout<<"删除失败"<<endl;
    cout<<"当前map元素个数："<<mapStudent.size()<<endl;
    cout<<"清空映射！";
    mapStudent.erase(mapStudent.begin(), mapStudent.end()); //清空
    cout<<"当前map元素个数："<<mapStudent.size()<<endl;
    return 0;
}
/********************************************************
运行结果：

1 : student_1
2 : student_2
3 : student__
4 : student..
5 : student..
6 : student..
7 : student..
8 : student..
9 : student..
当前map元素个数：9
该元素为student_1
删除成功
当前map元素个数：8
清空映射！当前map元素个数：0
********************************************************/

---------------------------------------------------------------------------------------------------------------------------

列表(list)

#include <list>

iterator begin();  //返回指向第一个元素的迭代器
iterator end();  //返回指向最后一个元素的迭代器
reverse_iterator rbegin();  //返回指向第一个元素的逆向迭代器
reverse_rend();  //返回指向最后一个元素的逆向迭代器
bool empty() const;  //list为空时返回true
size_type size() const;  //返回list容器里元素的个数
size_type max_size() const;  //返回list容器最大能容纳的元素的个数，主要用于调用list的resize()函数时，检查所请求的size大小是否被允许
reference front();  //返回第一个元素的引用
const_reference front() const;
reference back();  //返回最后一个元素的引用
const_reference front() const;
template<class InputIterator>
void assign(InputIterator first, InputIterator last);  //first,last是一个序列中起始和结束的迭代器的值，[first, last)包含了序列中所有元素
void assign(size_type n, const value_type& val);  //给list赋值n个值为val的元素
void push_front(const value_type& val);  //在list头添加元素
void pop_front();  //删除list头的元素
void push_back(const value_type& val);  //在list尾添加元素
void pop_back();  //删除list尾的元素
iterator insert (iterator position, const value_type& val);  //position是要插入的这个list的迭代器，val是要插入的值
void insert (iterator position, size_type n, const value_type& val);  //从该list容器中的position位置处开始，插入n个值为val的元素
template <class InputIterator>
void insert (iterator position, InputIterator first, InputIterator last);  //first，last是我们选择的把值插入到这个list中的值所在的容器的迭代器
iterator erase (iterator position);  //删除迭代器position指向的值，也可以不用变量接收其返回值
iterator erase (iterator first, iterator last);  //删除[first, last)中的值，也可以不用变量接收其返回值
void swap(list& x);  //要交换的两个列表的存储的元素的类型必须是一样的，列表大小可以不同
void resize (size_type n, value_type val = value_type());  //将list大小调整为能容纳n个元素，若n大于当前list大小，则会从list末尾一直插入val值，直到list大小满足n;
void clear();  //删除list的所有元素
void splice (iterator position, list& x);  //将列表x中的所有元素移到当前list中，从当前列表的position指向的位置开始，此时列表x为空
void splice (iterator position, list& x, iterator i);  //将列表x中迭代器 i 指向的元素移到当前list的position指向的位置处，由于i指向的元素从列表x中被移除，所以迭代器 i 此时是invalid的；position是当前列表的迭代器，i是列表x的迭代器
void splice (iterator position, list& x, iterator first, iterator last);  //将列表x中[first, last)的元素移到当前list中，从position指向的位置开始；first, last是列表x的迭代器
void remove (const value_type& val);  //从list中删除所有值为val的元素
template <class Predicate>
void remove_if (Predicate pred)；  //pred可以是一个函数，也可以是一个class，但它需要有一个参数，且参数类型跟list中存储元素类型相同，满足条件就返回true
void unique();  //只能删除相邻的重复元素，然后保留第一个值，因此这个函数只对排好序的list有用
template <class BinaryPredicate>
void unique (BinaryPredicate binary_pred);  //binary_pred可以是函数，也可以是class，但它需要有两个参数，且类型跟list中存储的值类型相同，满足某个条件就返回true
void merge(list &x);  //会将列表x中的元素按默认的顺序移入当前列表当中，此时列表x为空，当前列表仍为有序列表
template<class Compare>
void merge (list& x, Compare comp);  //comp可以为一个函数，要求有两个参数且参数类型跟list中存储的元素类型相同，当满足条件时返回true，merge就按照这个条件将两个列表合并
void sort();  //默认升序排列
template <class Compare>
void sort (Compare comp);  //comp可以是一个函数，要求有两个参数，类型跟list中元素类型相同，满足条件时返回true，sort()函数就按照comp中制定的规则对元素进行排序
void reverse();  //将list中元素的顺序逆转过来
allocator_type get_allocator() const;  //可以用来给数组动态分配空间

#include<list>
#include<iostream>
using namespace std;
void print(list<int> elemets){
    list<int>::iterator iter;
    for(iter = elemets.begin(); iter != elemets.end(); iter++){
        cout <<*iter << " ";
    }
    puts("");
    return;
}
int main()
{
    //定义list
    list<int> elemets;
    //定义list的迭代器

    //向list中当前的指针的位置插入到最后一位
    elemets.push_back(1);
    elemets.push_back(2);
    elemets.push_back(3);
    elemets.push_back(4);
    elemets.push_back(5);
    //向list中当前的指针的位置插入到最前一位
    elemets.push_front(5);
    elemets.push_front(4);
    elemets.push_front(3);
    elemets.push_front(2);
    elemets.push_front(1);
    //插入
    list<int>::iterator it = elemets.begin();
    for(int i=0;i<5;i++,it++);
    elemets.insert (it,1000);
    //进行迭代遍历
    cout <<"遍历：";
    print(elemets);
    puts("删除元素5");
    elemets.remove(5);
    print(elemets);
    cout << "删除首位元素后" << endl;

    //删除list的首位
    elemets.erase(elemets.begin());
    //进行遍历
    print(elemets);
    cout << "elements容量:" << elemets.size() << endl;
    cout << "清空elements！"<<endl;
    elemets.clear(); //清空list
    //判断list是否为空
    if(elemets.empty()){    //判空
        cout << "list为空" << endl;
    }

    //获取list的长度
    cout << "elements容量:" << elemets.size() << endl;
}

/********************************************************
运行结果：

遍历：1 2 3 4 5 1000 1 2 3 4 5
删除元素5
1 2 3 4 1000 1 2 3 4
删除首位元素后
2 3 4 1000 1 2 3 4
elements容量:8
清空elements！
list为空
elements容量:0
********************************************************/

---------------------------------------------------------------------------------------------------------------------------