备战蓝桥杯从STL库开始---最简单的几个容器

备战蓝桥杯从STL库开始—最简单的几个常用容器

1、STL库的介绍

学习C/C++语言的基础很简单，但是写写算法的能力不是人人都具备的，本人蒟蒻一枚，时常感觉算法的概念原理都懂，但就是写不出来东西，于是发现了一个“百宝箱”——STL(Standard Template Library,标准模板库)
一般分为algorithm（算法）、container（容器）和iterator（迭代器）三类。模板库内容主要包含了一些常用的算法如快速排序、简单查找等，当然还包括了一些常用的数据结构，如可变长数组、链表、字典等。
一般以它的高效著称。注解：打比赛return 0少不了！！！

2、基础知识

1. 快速排序sort

   sort排序是学习STL必须要知道的，内部算法结构是快速排序，不懂的同学可以先去了解一下快排的原理，毕竟手打快排也有可能在比赛场上需要。

   #include
   #include
   #include 
   using namespace std;
   int main(){
   	int a[10];
   	for(int i=0;i<10;i++){
   		a[i]=rand()%100;//存入十个随机数 
   	}
   	for(int i=0;i<10;i++){
   		cout<

   

   那么如何从大到小排序呢？

   其实sort方法有内置好的方法让你从大到小排序，在这里，我们讲一下如何自己写一个方法从大到小排序。

   #include
   #include
   #include 
   using namespace std;
   bool cmp(int x,int y){//这里的参数一定要是你排序类型的参数
   	return x>y;//从大到小排序 
   }
   int main(){
   	int a[10];
   	for(int i=0;i<10;i++){
   		a[i]=rand()%100;//存入十个随机数 
   	}
   	for(int i=0;i<10;i++){
   		cout<

    ![在这里插入图片描述](https://img-blog.csdnimg.cn/202104090001127.png)
   

   ​ 一般sort排序是针对字典序进行排序，所以当你是字符串数组的时候也是可以进行排序的，这一点大家可以自行尝试。同时还支持double类型的排序，也可以尝试一下。

   ​ 针对结构体数据也可以使用sort进行排序，我们以输入学生成绩进行排序为例子，每个学生都有3门课的成绩:语文、数学、英语。先按总分从高到低排序，如果两个同学总分相同，再按语文成绩从高到低排序，如果两个同学总分和语文成绩都相同，那么规定学号小的同学排在前面。

   #include
   #include
   using namespace std;
   int n;
   struct stu{
   	int num;//学号 
   	int c,m,e;//三科成绩 
   	int sum;//总分 
   }student[310];//定义学生的结构体类型 
   bool cmp(stu a,stu b){
   	if(a.sum>b.sum){
   		return a.sum>b.sum;
   	}else if(a.sumb.c){
   			return a.c>b.c;
   		}else if(a.c> n;
   	for(int i=1;i<=n;i++){
   		student[i].num=i;
   		cin>>student[i].c>>student[i].m>>student[i].e;
   		student[i].sum=student[i].c+student[i].m+student[i].e;
   	}
   	sort(student+1,student+n+1,cmp);
   	for(int i=1;i<=5;i++)
           cout<

2. vector 向量容器

   vector 向量容器是一种简单高效的容器，在尾端插入和删除元素，算法时间为O(1)，其他元素插入和删除时间为O(n)。vector可动态调整所占用的内存空间。

   在此之前导入**#include**

   vector，T代表类型，类似于你定义数组的类型一样。

   也被称为动态数组，当你做题目的时候如果遇到数组空间大小不确定的情况下，可以考虑使用它，同样也很高效，首先要了解它常用的几种方法。

   1. 如何存数据？

      #include
      #include
      using namespace std;
      
      
      
      int main(){
      	vector < int > v ;
      	v.push_back(30);                                    //此时是从尾端插入新元素
      	v.push_back(23);
      	v.push_back(11);
      	return 0;
      }
      

   2. 如何取数据

      1. 采取数组的方式读取数据

         #include
         #include
         using namespace std;
         
         int main(){
         	vector < int > v ;
         	v.push_back(30);                                    //此时是从尾端插入新元素
         	v.push_back(23);
         	v.push_back(11);
         	for(int i = 0 ; i < v.size() ; i++ ){
         		cout<

      2. 采取迭代器的方式读取数据

      #include
      #include
      using namespace std;
      int main(){
      	int j ;
      	vector < int > v ;
      	v.push_back (11) ;                                    //尾插入新元素
      	v.push_back (23) ;
      	//	v.clear () ;                                      //清空全部元素             
      	v.push_back (30) ;
          v.push_back(1);
          v.push_back(16);
      	v.insert ( v.begin() + 3 , 41 ) ;                     //插入41在第3个元素的后面
          //一定要去动手验证一下结果
      	v.insert ( v.begin(), 15 ) ;                        //插入15为首元素
      	v.insert ( v.end(), 12 ) ;                          //插入12为末元素
          
      	v.erase ( v.begin() + 2) ;                           //删除第三个元素
      	v.erase ( v.begin() , v.begin() + 2 ) ;              //删除前三个元素
       	
          //迭代器访问
          vector < int > :: iterator i ;                     
       	for( i=v.begin(),j=0;i!=v.end();i++,j++ ){//从头到尾来进行扫描
       		cout<<"v["<#include
      #include
      using namespace std;
      
      struct stu{
      	int x;
      	int y;
      };
      
      int main()
      {
      	int j ;
      	vector  v1 ;                                  //声明结构体容器
      	vector  v2 ;
      	struct stu a1={1,2};
      	struct stu a2={2,3};
      	struct stu a3={4,5} ;
      	v1.push_back( a );
      	v1.push_back( b );
      	v1.push_back( c );
          //压入数据
      	v2.push_back( c );
      	v2.push_back( b );
      	v2.push_back( a );
      	//读取出数据
      	for(int i=0; i

      更多的vector 的使用，还得到实际的场景中去实际操作。

3. set容器

   set集合容器使用一种红黑树的平均二叉检索树，不会将重复键值插入，检索使用二叉树的中序遍历，因此可以将元素从小到大排列出来。同时保证数据不重复，可以理解为集合中元素不重复一样

   使用时注意包含头文件**#include**

   1.set容器的常用操作

   s.begin()     　返回set容器的第一个元素
   s.end() 　　　　 返回set容器的最后一个元素
   s.clear()       删除set容器中的所有的元素
   s.empty() 　　　 判断set容器是否为空
   s.insert()      插入一个元素
   s.erase()       删除一个元素
   s.size() 　　　　返回当前set容器中的元素个数
   

   ---

   2.set容器的创建

   #include 
   #include 
   using namespace std;
   
   int main(){
   	set s;
   }
   

   ---

   3.set容器的操作

   //插入操作
   #include 
   #include 
   using namespace std;
   int main(){
   	sets;
       int cnt = 1;
       s.insert(1);
       s.insert(2);
       s.insert(5);
       for(set::iterator it = s.begin(); it!= s.end(); it++)
           cout << *it << " ";
       s.insert(2); //set只允许用一个值出现一次，要插入相同元素请用multiset
   	for(set::iterator it = s.begin(); it!= s.end(); it++)
           cout << *it << " ";
           
       int a[4] = {11,12,13,14};
       s.insert(a,a+4); //将区间[a, a+4]里的元素插入容器
    	for(set::iterator it = s.begin(); it!= s.end(); it++)
           cout << *it << " ";
       return 0;
   }
   
   //删除操作
   //s.erase()       //删除一个元素
   #include 
   #include 
   using namespace std;
   sets;
   int main(){
       int cnt = 1;
       for(int i = 1; i < 11; i++){
           s.insert(i);
       }
       setprint(cnt++);
    
       s.erase(9); //根据元素删除
       for(set::iterator it = s.begin(); it!= s.end(); it++)
           cout << *it << " ";
    
       set::iterator ita = s.begin();
       set::iterator itb = s.begin();
       s.erase(ita);  //删除迭代器指向位置的元素
       for(set::iterator it = s.begin(); it!= s.end(); it++)
           cout << *it << " ";
    
       ita = s.begin();
       itb = s.begin();
       itb++;itb++;
       s.erase(ita,itb); //删除区间[ita,itb)的元素
       for(set::iterator it = s.begin(); it!= s.end(); it++)
           cout << *it << " ";
       s.clear();
       return 0;
   }
   
   //查找操作
   //s.find()        查找一个元素，如果容器中不存在该元素，返回值等于s.end()
   #include 
   #include 
   using namespace std;
   sets;
   int main(){
       int cnt = 1;
       s.insert(1);
       s.insert(2);
       s.insert(5);
       for(set::iterator it = s.begin(); it!= s.end(); it++)
           cout << *it << " ";
    
       if(s.find(2) != s.end()) 
           cout << "2 is existent" << endl;
       else 
           cout << "2 is non-existent" << endl;
       if(s.find(3) == s.end()) 
           cout << "3 is non-existent" << endl;
       else 
           cout << "2 is existent" << endl;
       return 0;
   }
   
   //判断元素是否在set中 & 判断set是否为空
   #include 
   #include 
   #include 
   using namespace std;
   int main(){
       set s;
       if(s.empty()) cout << "容器为空" << endl;
       s.insert(1);
       if(!s.empty()) cout << "容器不为空" << endl;
    
       if(s.count(1)) cout << "1在容器中" << endl;
       if(!s.count(2)) cout << "2不在容器中" << endl;
       return 0;
   }
   
   //自定义比较函数
   #include 
   #include 
   #include 
   using namespace std;
    
   struct cmp{
       bool operator () (const int &a, const int &b){
           return a > b;
       }
   };
   sets; //自定义排序函数构造set
   int main(){
       s.insert(1);
       s.insert(2);
       s.insert(6);
       for(set::iterator it = s.begin(); it!= s.end(); it++)
           cout << *it << " ";
       return 0;
   }
   

4. stack容器

   stack，俗称为“栈”。可以先去了解一下栈结构再来看看。

   由于栈是后进后出的数据结构，因此STL中的stack中只能通过top（）来访问栈顶元素。用来模拟实现一些递归。（防止程序对栈内存的限制而导致程序运行错误）

   一般来说，程序的栈内存空间很小，若用普通的函数来递归，一旦层数过深，则会导致程序运行崩溃。用栈来模拟递归算法的实现，则可以避免这一方面的问题.

   导入前加入头文件#include

   1. 常见操作

      empty：判断堆栈元素是否为空，true表示栈元素为空；
      pop：移除栈顶元素；
      push：栈顶添加元素；
      top：返回栈顶元素；
      size：返回栈中元素数目；
      

   2. 具体实现

      #include
      #include
      using namespace std;
      int main(){
          stack st;
          if(st.empty()==true){//输出Empty
              printf("Empty\n");
          }else{
              printf("Not Empty\n");
          }
          for(int i  = 1; i < 5; i++){
              st.push(i);
          }
          printf("%d\n",st.top);//top()取栈顶元素，输出为5
          printf("%d\n",st.size());
          for(int i  = 1; i < 5; i++){
              st.pop(i);
          }
          printf("%d\n",st.top);//top()取栈顶元素，输出为5
          printf%d\n",st.size());
      }
      

5. queue容器

   queue与stack模版非常类似，queue模版也需要定义两个模版参数，一个是元素类型，一个是容器类型，元素类型是必要的，容器类型是可选的，默认为dqueue类型。

   队列的知识建议百度搜一下就懂了，提前知道什么是队列再看。

   queue q1;
   queue q2;
   

   1. 基本操作

      入队，如例：q.push(x); 将x 接到队列的末端。
      出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。
      访问队首元素，如例：q.front()，即最早被压入队列的元素。
      访问队尾元素，如例：q.back()，即最后被压入队列的元素。
      判断队列空，如例：q.empty()，当队列空时，返回true。
      访问队列中的元素个数，如例：q.size()
      

   2. 具体实现

      #include 
      #include 
      #include 
        
      using namespace std;
        
      int main()
      {
          int e,n,m;
          queue q1;
          for(int i=0;i<10;i++)
             q1.push(i);
          if(!q1.empty())
          cout<<"dui lie  bu kong\n";
          n=q1.size();
          cout<

   队列中还有很多知识，其中最重要的是优先队列，这个要花一些时间去理解，往后再说，同时利用优先队列做的题目也不再少数，很多都是搜索方面的题目，下一次一起拿一些题目一起单独聊聊优先队列和大小堆的知识点