zoukankan      html  css  js  c++  java
  • STL之容器基本操作

    容器类
    STL Container Header Applications
    vector <vector> 直接访问任意元素,快速插入、删除尾部元素
    deque <deque> 直接访问任意元素,快速插入、删除头部和尾部元素
    list <list> 快速插入、删除任意位置元素
    set <set> 快速查询元素,无重复关键字
    multiset <set> 与set相同,但允许重复关键字
    map <map> Key/value pair mapping(键值对映射)。不允许重复关键字,使用关键字快速查询元素
    multimap <map> 与map相同,但允许重复关键字
    stack <stack> 后进先出容器.
    queue <queue> 先进先出容器
    priority_queue <queue> 高优先级元素先删除
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     

    所有容器共同函数
    Functions Description
    non-argconstructor 无参构造函数 构造一个空容器
    constructor with args带参构造函数 每个容器都有多个带有参数的构造函数
    copy constructor 拷贝构造函数 创建一个容器,从一个已有的同类型容器中复制元素
    destructor 析构函数 容器销毁后执行清理工作
    empty() 若容器中没有元素则返回空
    size() 返回容器中的元素数目
    operator= 将容器内容复制到另一个容器
    Relational operators(<, <=, >, >=, ==, and !=) 顺序比较两个容器中的对应元素,来确定大小关系
    一级容器的通用函数
    顺序容器+关联容器= 一级容器
    Functions Description 
    c1.swap(c2) 交换两个容器c1和c2的内容
    c1.max_size() 返回一个容器可以容纳的最大元素数量
    c.clear() 删除容器中的所有元素
    c.begin() 返回容器首元素的迭代器
    c.end() 返回容器尾元素之后位置的迭代器
    c.rbegin() 返回容器为元素的迭代器,用于逆序遍历
    c.rend() 返回容器首元素之前位置的迭代器,用于逆序遍历
    c.erase(beg, end) 删除容器中从beg到end-1之间的元素。beg和end都是迭代器

    顺序容器(Sequence Container)

    1.vector(向量)连续存储的元素。直接访问任意元素,快速插入、删除尾部元素。<vector>
    2.双端队列(deque) 连续存储的指向不同元素的指针所组成的数组。直接访问任意元素,快速插入、删除头部和尾部元素。<deque>
    3.列表(list) 由节点组成的双向链表,每个结点包含着一个元素。快速插入、删除任意位置元素。<list>
     
    顺序容器的共同函数
    函数 描述
    assign(n, elem) 将指定元素elem的n份拷贝加入(赋值)到容器中
    assign(begin, end) 将迭代器[beg,end)间的元素赋值给当前容器
    push_back(elem) 将元素附加到容器
    pop_back() 删除容器尾元素
    front 返回容器首元素
    back() 返回容器尾元素
    insert(position, elem) 将元素插入到容器指定位置
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
    #include <iostream>
     2 #include <vector>
     3 using namespace std;
     4 
     5 int main()
     6 {
     7   double values[] = {1, 2, 3, 4, 5, 6, 7};
     8   // 构造向量,用迭代器[beg, end)间的元素初始化向量 
     9   vector<double> doubleVector(values, values + 7);
    10 
    11   cout << "Initial contents in doubleVector: ";
    12   for (int i = 0; i < doubleVector.size(); i++)
    13     cout << doubleVector[i] << " ";
    14 
    15   // 顺序容器:assign(n, elem) 将n份元素拷贝赋值给容器 
    16   doubleVector.assign(4, 11.5);
    17 
    18   cout << "
    After the assign function, doubleVector: ";
    19   for (int i = 0; i < doubleVector.size(); i++)
    20     cout << doubleVector[i] << " ";
    21 
    22   // vector/deque中特有的函数at(index)返回指定位置的元素 
    23   doubleVector.at(0) = 22.4;
    24   cout << "
    After the at function, doubleVector: ";
    25   for (int i = 0; i < doubleVector.size(); i++)
    26     cout << doubleVector[i] << " ";
    27 
    28   // 定义迭代器,令其指向向量首位置 
    29   vector<double>::iterator itr = doubleVector.begin();
    30   // 顺序容器:insert(position, elem) 将元素插入指定位置 
    31   doubleVector.insert(itr + 1, 555);
    32   // !!!警告!!! 调用vector的insert之后,所有的迭代器都【可能】失效! 
    33   // doubleVector.insert(itr + 1, 666);  // itr可能会失效
    34   itr = doubleVector.begin();
    35   doubleVector.insert(itr + 1, 666);
    36    
    37   cout << "
    After the insert function, doubleVector: ";
    38   for (int i = 0; i < doubleVector.size(); i++)
    39     cout << doubleVector[i] << " ";
    40 
    41   // 一级容器: erase[beg, end) 删除指定迭代器范围的元素 
    42   doubleVector.erase(itr + 2, itr + 4);
    43   //!!!警告!!! 调用vector的erase之后,beg及之后的迭代器都会失效!
    44    
    45   cout << "
    After the erase function, doubleVector: ";
    46   for (int i = 0; i < doubleVector.size(); i++)
    47     cout << doubleVector[i] << " ";
    48 
    49   doubleVector.clear();
    50   cout << "
    Size is " << doubleVector.size() << endl;
    51   cout << "Is empty? " <<
    52         (doubleVector.empty() ? "true" : "false") << endl;
    53 
    54   return 0;
    #include <iostream>
     2 #include <deque>
     3 using namespace std;
     4 
     5 int main()
     6 {
     7   double values[] = {1, 2, 3, 4, 5, 6, 7};
     8   // 构造deque,用迭代器[beg, end)间的元素初始化deque  
     9   deque<double> doubleDeque(values, values + 7);
    10 
    11   cout << "Initial contents in doubleDeque: ";
    12   for (int i = 0; i < doubleDeque.size(); i++)
    13     cout << doubleDeque[i] << " ";
    14 
    15   // 顺序容器:assign(n, elem) 将n份元素拷贝赋值给容器 
    16   doubleDeque.assign(4, 11.5);
    17   cout << "
    After assign: ";
    18   for (int i = 0; i < doubleDeque.size(); i++)
    19     cout << doubleDeque[i] << " ";
    20 
    21   // deque/vector中特有:at(index)返回指定位置的元素 
    22   doubleDeque.at(0) = 22.4;
    23   cout << "
    After at: ";
    24   for (int i = 0; i < doubleDeque.size(); i++)
    25     cout << doubleDeque[i] << " ";
    26 
    27   deque<double>::iterator itr = doubleDeque.begin();
    28   // 顺序容器:insert(position, elem) 将元素插入指定位置 
    29   doubleDeque.insert(itr + 1, 555);
    30   // doubleDeque.insert(itr + 1, 666); // Error! Unexpected Behavior
    31   // !!!警告!!! 调用deque的insert之后,所有的迭代器都【必然】失效!
    32   //  
    33   itr = doubleDeque.begin(); // 重新获得迭代器 
    34   doubleDeque.insert(itr + 1, 666);
    35   
    36   cout << "
    After insert: ";
    37   for (int i = 0; i < doubleDeque.size(); i++)
    38     cout << doubleDeque[i] << " ";
    39 
    40   // 一级容器:erase[beg, end) 删除指定迭代器范围的元素
    41   doubleDeque.erase(itr + 2, itr + 4);
    42   // !!!警告!!! 调用deque的erase之后,所有的迭代器都【可能】失效!
    43   cout << "
    After erase: ";
    44   for (int i = 0; i < doubleDeque.size(); i++)
    45     cout << doubleDeque[i] << " ";
    46 
    47   doubleDeque.clear();
    48   cout << "
    After clear: ";
    49   cout << "Size is " << doubleDeque.size() << endl;
    50   cout << "Is empty? " <<
    51         (doubleDeque.empty() ? "true" : "false") << endl;
    52 
    53   // deque/list特有:push_front(elem)将元素压入队头 
    54   doubleDeque.push_front(10.10); // 10.10 
    55   doubleDeque.push_front(20.22); // 20.22 10.10
    56   doubleDeque.push_front(30.33); // 30.33 20.22 10.10
    57   cout << "After push_front: ";
    58   for (int i = 0; i < doubleDeque.size(); i++)
    59     cout << doubleDeque[i] << " ";
    60 
    61   // deque/list特有:pop_front()删除队首元素 
    62   doubleDeque.pop_front();
    63   // 顺序容器:pop_back()删除容器尾元素 
    64   doubleDeque.pop_back();
    65   cout << "
    After pop: ";
    66   for (int i = 0; i < doubleDeque.size(); i++)
    67     cout << doubleDeque[i] << " ";
    68 
    69   return 0;
    70 }
    #include <iostream>
      2 #include <list>
      3 using namespace std;
      4 
      5 int main()
      6 {
      7   int values[] = {1, 2, 3, 4 };
      8   // 构造list,用迭代器[beg, end)间的元素初始化list 
      9   list<int> intList(values, values + 4);
     10 
     11   cout << "Initial contents in intList: ";
     12   list<int>::iterator p; // list的迭代器为双向迭代器 
     13   for (p = intList.begin(); p != intList.end(); p++)
     14     cout << *p << " ";
     15 
     16   // 顺序容器:assign(n, elem) 将n份元素拷贝赋值给容器 
     17   intList.assign(4, 11);
     18   cout << "
    After assign, intList: ";
     19   for (p = intList.begin(); p != intList.end(); p++)
     20     cout << *p << " ";
     21 
     22   list<int>::iterator itr = intList.begin();
     23   itr++;  // 迭代器指向第2个11:  11  ^11  11  11 
     24   // 顺序容器:insert(position, elem) 将元素插入指定位置 
     25   intList.insert(itr, 555); // 11  555  ^11  11  11 
     26   // 调用list的insert之后,迭代器不受影响,仍指向第2个11 
     27   intList.insert(itr, 666); // 11  555  666  ^11  11  11
     28   cout << "
    After insert, intList: ";
     29   for (p = intList.begin(); p != intList.end(); p++)
     30     cout << *p << " ";
     31 
     32   list<int>::iterator beg = intList.begin();
     33   itr++;
     34   // 一级容器: erase[beg, end) 删除指定迭代器范围的元素 
     35   intList.erase(beg, itr);
     36   // !!!警告!!! 被删除元素的迭代器均失效,其它元素迭代器仍有效 
     37   cout << "
    After erase, intList: ";
     38   for (p = intList.begin(); p != intList.end(); p++)
     39     cout << *p << " ";
     40 
     41   intList.clear();
     42   cout << "
    After clear, intList: ";
     43   cout << "Size is " << intList.size() << endl;
     44   cout << "Is empty? " <<
     45         (intList.empty() ? "true" : "false");
     46 
     47   // deque/list特有:push_front(elem)将元素插入列表首部 
     48   intList.push_front(10);
     49   intList.push_front(11);
     50   intList.push_front(12);
     51   cout << "
    After push, intList: ";
     52   for (p = intList.begin(); p != intList.end(); p++)
     53     cout << *p << " ";
     54 
     55   // deque/list特有:pop_front()删除列表首元素 
     56   intList.pop_front();
     57   // 顺序容器:pop_back()删除容器尾元素 
     58   intList.pop_back();
     59   cout << "
    After pop functions, intList: ";
     60   for (p = intList.begin(); p != intList.end(); p++)
     61     cout << *p << " ";
     62 
     63   int values1[] = {7, 3, 1, 2};
     64   list<int> list1(values1, values1 + 4);
     65   // list特有:sort() 将元素按升序排列 
     66   list1.sort();
     67   cout << "
    After sort, list1: ";
     68   for (p = list1.begin(); p != list1.end(); p++)
     69     cout << *p << " ";
     70 
     71   list<int> list2(list1);
     72   // list特有:merge(l2) 假定当前list与list2都已排序,
     73   //           将list2合并至本表,list2变空 
     74   list1.merge(list2);
     75   cout << "
    After merge, list1: ";
     76   for (p = list1.begin(); p != list1.end(); p++)
     77     cout << *p << " ";
     78   cout << "
    Size of list2 is " << list2.size();
     79 
     80   // list特有:reverse()反转本列表 
     81   list1.reverse();
     82   cout << "
    After reverse, list1: ";
     83   for (p = list1.begin(); p != list1.end(); p++)
     84     cout << *p << " ";
     85 
     86   list1.push_back(7);
     87   list1.push_back(1);
     88   cout << "
    After push, list1: ";
     89   for (p = list1.begin(); p != list1.end(); p++)
     90     cout << *p << " ";
     91 
     92   // list特有:remove(elem)删除表中与elem相等的元素 
     93   list1.remove(7);
     94   cout << "
    After remove, list1: ";
     95   for (p = list1.begin(); p != list1.end(); p++)
     96     cout << *p << " ";
     97 
     98   // 顺序容器:assign(n, elem) 将n份elem拷贝赋值给容器 
     99   list2.assign(7, 2);
    100   cout << "
    After assign, list2: ";
    101   for (p = list2.begin(); p != list2.end(); p++)
    102     cout << *p << " ";
    103 
    104   p = list2.begin();
    105   p++;
    106   // list特有:splice(pos,li)将li中所有元素移至本表pos位置之前
    107   //           然后li变空 
    108   list2.splice(p, list1);
    109   cout << "
    After splice, list2: ";
    110   for (p = list2.begin(); p != list2.end(); p++)
    111     cout << *p << " ";
    112   cout << "
    After splice, list1 size: "
    113     << list1.size();
    114 
    115   return 0;
    116 }
    容器适配器(Container Adapters)

      Features:
        ①由顺序容器变化而来
        ②程序员可为适配器选择合适的顺序容器

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

      stack<ElementType> st;     //创建一个空栈st

      st.push(ElementType);      //在栈顶增加元素

      st.pop();             //移除栈顶元素(不会返回栈顶元素的值)

      st.top();              //返回栈顶元素

      st.empty();           //判断栈是否为空,空则返回true

      st.size();            //返回栈中元素数目

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

      queue<ElementType> q;    //创建一个空队列

      q.push(ElementType);      //将一个元素置入queue中

      q.pop();             //从queue中移除一个元素(不会返回队头元素值)

      q.front();                 //返回queue内的第一个元素(也就是第一个被置入的元素)

      q.back();            //返回queue中最后一个元素(也就是最后被插入的元素)

      q.empty();           //判断队列是否为空,空则返回true

      q.size();            //返回队列中元素数目。

      注意:pop()虽然会移除下一个元素,但是并不返回它,front()和back()返回下一个元素但并不移除该元素。

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

      priority_queue<ElementType> pq;     //创建一个数据越大,优先级越高的队列

      priority_queue<int, vector<int>, greater<int> > pq;  //创建一个数据越小,优先级越高的队列

      pq.push(ElementType);    //将一个元素置入priority_queue中

      pq.pop();           //从priority_queue中移除一个元素(不会返回队头元素值)

      pq.top();            //返回priority_queue中优先级最高的元素

      pq.empty();           //判断priority_queue是否为空,空则返回true

      pq.size();           //返回priority_queue中元素数目

      自定义优先级,重载比较符号

      重载默认的 < 符号

    1 struct node
    2 {
    3     friend bool operator< (node n1, node n2)
    4     {
    5         return n1.priority < n2.priority;
    6     }
    7     int priority;
    8     int value;
    9 };

    这时,需要为每个元素自定义一个优先级。

      注:重载>号会编译出错,因为标准库默认使用元素类型的<操作符来确定它们之间的优先级关系。
      而且自定义类型的<操作符与>操作符并无直接联系

    #include<iostream>
     2 #include<functional>
     3 #include<queue>
     4 using Namespace stdnamespace std;
     5 struct node
     6 {
     7     friend bool operator< (node n1, node n2)
     8     {
     9         return n1.priority < n2.priority;
    10     }
    11     int priority;
    12     int value;
    13 };
    14 int main()
    15 {
    16     const int len = 5;
    17     int i;
    18     int a[len] = {3,5,9,6,2};
    19     //示例1
    20     priority_queue<int> qi;
    21     for(i = 0; i < len; i++)
    22         qi.push(a[i]);
    23     for(i = 0; i < len; i++)
    24     {
    25         cout<<qi.top()<<" ";
    26         qi.pop();
    27     }
    28     cout<<endl;
    29     //示例2
    30     priority_queue<int, vector<int>, greater<int> >qi2;
    31     for(i = 0; i < len; i++)
    32         qi2.push(a[i]);
    33     for(i = 0; i < len; i++)
    34     {
    35         cout<<qi2.top()<<" ";
    36         qi2.pop();
    37     }
    38     cout<<endl;
    39     //示例3
    40     priority_queue<node> qn;
    41     node b[len];
    42     b[0].priority = 6; b[0].value = 1; 
    43     b[1].priority = 9; b[1].value = 5; 
    44     b[2].priority = 2; b[2].value = 3; 
    45     b[3].priority = 8; b[3].value = 2; 
    46     b[4].priority = 1; b[4].value = 4; 
    47 
    48     for(i = 0; i < len; i++)
    49         qn.push(b[i]);
    50     cout<<"优先级"<<'	'<<""<<endl;
    51     for(i = 0; i < len; i++)
    52     {
    53         cout<<qn.top().priority<<'	'<<qn.top().value<<endl;
    54         qn.pop();
    55     }
    56     return 0;
    57 }
    关联式容器(Associative Containers)

      Features:
        ①使用“key”快速存取元素
        ②元素按规则排序
        ③默认用< 运算符排序

    7.集合(set) 由节点组成的红黑树,每个节点都包含着一个元素,节点之间以某种作用于元素对的谓词排列,没有两个不同的元素能够拥有相同的次序 。快速查询元素,无重复关键字。<set>
    8.多重集合(multiset) 允许存在两个次序相等的元素的集合。与set相同,但允许重复关键字<set>
    9.映射(map) 由{键,值}对组成的集合,以某种作用于键对上的谓词排列。Key/value pair mapping(键值对映射)。不允许重复关键字,使用关键字快速查询元素 <map>
    10.多重映射(multimap) 允许键对有相等的次序的映射。与map相同,但允许重复关键字 <map>
     
    关联容器中的共同函数
    函数 描述
    find(key) 搜索容器中具有key的元素,返回指向该元素的迭代器
    lower_bound(key) 搜索容器中具有key的第一个元素,返回指向该元素的迭代器
    upper_bound(key) 搜索容器中具有key的最后一个元素,返回指向该元素之后位置的迭代器
    count(key) 返回容器中具有key的元素的数目
     
     
     
     
     
     
     
     
     
    #include <iostream>
     2 #include <set>
     3 using namespace std;
     4 
     5 int main()
     6 {
     7   int values[] = {3, 5, 1, 7, 2, 2};
     8   // 构造multiset,用迭代器[beg, end)间的元素初始化deque 
     9   // 升序排列  1,2,2,3,5,7 
    10   multiset<int> set1(values, values + 6);
    11   // 降序排列  7,5,3,2,2,1
    12   //  multiset<int, greater<int> > set1(values, values + 6);
    13   
    14   cout << "Initial contents in set1: ";
    15   multiset<int>::iterator p;
    16   for (p = set1.begin(); p != set1.end(); p++) // set支持双向迭代器 
    17     cout << *p << " ";
    18 
    19   set1.insert(555); // 1,2,2,3,5,7,555 
    20   set1.insert(1);   // 1,1,2,2,3,5,7,555
    21   cout << "
    After insert, set1: ";
    22   for (p = set1.begin(); p != set1.end(); p++)
    23     cout << *p << " ";
    24 
    25   p = set1.lower_bound(2); // p指向容器中第一个2 
    26   cout << "
    Value of Lower bound of 2: " << *p;
    27   p = set1.upper_bound(2); // p指向容器中最后一个2的后面 
    28   cout << "
    Value of Upper bound of 2: " << *p;
    29 
    30   p = set1.find(2);
    31   if (p == set1.end()) // 若迭代器指向set尾部,则未找到 
    32     cout << "2 is not in set1" << endl;
    33   else
    34     cout << "
    The number of 2: " << set1.count(2);
    35 
    36   set1.erase(2); // 将所有值为2的元素都删掉 
    37   cout << "
    After erase, set1: ";
    38   for (p = set1.begin(); p != set1.end(); p++)
    39     cout << *p << " ";
    40 
    41   return 0;
    42 }
    #include <iostream>
     2 #include <map>
     3 #include <string>
     4 using namespace std;
     5 
     6 int main()
     7 {
     8   map<int, string> map1;
     9   // 插入键值对 
    10   map1.insert(map<int, string>::value_type(100, "Zhang San"));
    11   map1.insert(map<int, string>::value_type(101, "Li Si"));
    12   map1.insert(map<int, string>::value_type(102, "Zhen Xiaosa"));
    13   map1.insert(map<int, string>::value_type(103, "Hao Meili"));
    14 
    15   cout << "Initial contents in map1:
    ";
    16   map<int, string>::iterator p;
    17   for (p = map1.begin(); p != map1.end(); p++)
    18     cout << p->first << " " << p->second << endl;
    19     // 使用 first 访问 key; 使用 second 访问 value 
    20     
    21   cout << "Enter a key to serach for the name: ";
    22   int key;
    23   cin >> key;
    24   p = map1.find(key);
    25 
    26   if (p == map1.end()) // 若迭代器指向map尾部,则未找到指定键 
    27     cout << "  Key " << key << " not found in map1";
    28   else    
    29     cout << "  " << p->first << " " << p->second << endl;
    30 
    31   map1.erase(103);
    32   cout << "
    After erase 103, map1:
    ";
    33   for (p = map1.begin(); p != map1.end(); p++)
    34     cout << p->first << " " << p->second << endl;
    35 
    36   return 0;
    37 }
  • 相关阅读:
    AT+CNMI的使用
    oracle 触发器及游标的使用
    索引优缺点
    SQL Server里的主键、唯一性约束、聚集索引
    C++中使用内存映射文件处理大文件
    oracle 学习笔记
    香干炒肉丝
    如何将数据导入到 SQL Server Compact Edition 数据库中
    解决ORACLE密码遗忘
    Office 2003 主 Interop 程序集的安装和使用
  • 原文地址:https://www.cnblogs.com/ranjiewen/p/6649220.html
Copyright © 2011-2022 走看看