Sort排序+STL队列+优先队列小结

    Sort排序：

        普通数组：

                          sort排序比qsort排序简单多了，这里只对sort排序做了总结。

        头文件：   #include<algorithm> using namespace std ;

                         sort(数组名，数组名+元素个数) ；例如：int/char/double  a[ 1000 ] ; 假设里面已经赋了n个值，sort(a,a+n);这是从小到大排序。 sort(数组名，数组名+元素个数，cmp) ;int/char/double  cmp(int/char/double  a ,int/char/double  b ){    return  a > b ;    }从大到小排序。

       结构体排序：

       直接上代码：

#include<stdio.h>
#include<algorithm>
using namespace std;
struct zhang
{
    int x,y;
}t[1000];
bool cmp(zhang a,zhang b)
{
    return a.x > b.x ;//按x从大到小排序 "<"从小到大排序 同普通数组
    // strcmp(a.s,b.s) > 0 ? 1 : 0 ; // 比较字符串，大于0 降序，反之升序
}
int main()
{
     for(int i=0;i<10;i++)
       scanf("%d%d",&t[i].x,&t[i].y);
       sort(t,t+9,cmp);
    for(int i=0;i<9;i++)
      printf("%d %d\n",t[i].x,t[i].y);
    return 0;
}

 

  STL队列：

      概念：  Queue队列容器是一个先进先出的线性存储表，元素的插入只能在队尾，元素的删除只能在队首。

使用Queue需要声明头文件“#include <queue>  + using namespace std ”;

   基本运算：     

                 queue<int>q;申请q的队列

                 q.push()：入队，即插入元素

                 q.pop()：出队，即删除元素

                 q.front()：读取队首元素

                 q.back()：读取队尾元素

                 q.empty()：判断队列是否为空，是返回 1 ，不是返回 0 。

                 q.size()：队列当前元素有多少

STL 栈 ：

   概念： 栈和队列其实差不多，栈是后进先出的一种线性存储表。使用时需要申明头文件“#include<stack> + using namespace std ”。不管栈还是队列在做题时运行完一定要记得清空。

基本运算：

        stack<int>s ;申请栈

        s.push( ) : 入栈，即插入元素

        s.pop( ) : 出栈，即删除元素

        s.top( ) : 读取队首元素（此处与队列不同）

        s.empty( ) : 判断队列是否为空，是返回 1 ，不是返回 0 。

        s.size( ) : 栈当前元素有多少

  优先队列：

    概念：  优先队列和STL队列不同之处就是优先队列可以按照优先级出队（可以进行排序），在优先队列中，优先级高的元素先出队列。标准库默认使用元素类型的 < 操作符来确定它们之间的优先级关系。如果不写结构体默认为大的优先，如果想让小的先出队：priority_queue<int, vector<int>, greater<int> >qi2;

    基本运算：头文件#include<queue> using namespace std;

#include<stdio.h>
#include<queue>
using namespace std;
struct zhang  
{  
   int x,y,z;  
     friend bool operator<(const zhang &a,const zhang &b)//operator后 " < " 很重要！！
    {  
            return a.x < b.x ;//从大到小出队 " > " 从小到大出队 
    }  
  
};  
priority_queue<zhang>q;//尽量把这个放进int main（）里
zhang current,next; 

比较多个数出队：

#include<stdio.h>
#include<queue>
using namespace std;
struct zhang  
{  
   int x,y,z;  
     friend bool operator<(const zhang &a,const zhang &b)
    {  
        if(a.x!=b.x)
             return a.x < b.x ;//从大到小出队 " > " 从小到大出队(和普通排序相反) 
        else if(a.y!=b.y)
             return a.y > b.y ;//从大到小出队
        else 
             return a.z < b.z ;
    }  
  
};  
priority_queue<zhang>q;
zhang current,next; 

不比较优先级：

#include<stdio.h>
#include<queue>
using namespace std;
struct zhang
{
   int x,y,z;
};
queue<zhang>q;
zhang current,next;

deque（双端队列）

简介：

         deque  双端队列容器 ( double - ended queue ) 与 vector 非常相似，deque 内部的数据机制和执行性能与 vector 不同，一般来说，当考虑到容器元素的内存分配策略和操作的性能时 ，deque 相对于 vector 较为有优势。deque 双端队列采用分块的线性结构来存储数据，具有高效的删除首位元素的函数，由于 deque 容器是以 deque 块为单位进行内存的分配，并使用了二级的 Map 进行管理，因此不容易实现类似于 vector 的 capacity 和 reverse 函数，而且 deque 容器也不需要这样的获取和调整容大小的函数。

操作：

       创建：

         deque<类型>对象名；

         deque<int>q ;  // 创建一个空的deque对象； 

          deque<int>q(20) //创建具有n个元素的deque对象；

          deque<int>q(20 ,5) ;// 创建一个具有n个元素的deque对象，每个元素具有初始值(这里为 5)；

          deque<int> q(20 ,5) ; deque<int> p(q) ; //拷贝对象

           int a[10] = {1 ,2 ,3} ,deque<int> q(a ,a+3) ; // 拷贝区间的元素

    插入：

           q.push_front()  ; // 在头部插入元素

           q.push_back() ; // 在尾部插入元素

    删除：

            q.pop_front() ; // 删除头部元素

            q.pop_back() ; // 删除尾部元素

             q.erase(q.begin() + x)  ;// 删除某个位置的元素

             q.clear() ; // 清空容器

     遍历：

            deque<int>::iterator i ,j ; // 遍历器

     交换：

             q.swap(p) ; // 两个容器的元素交换

     vector的功能deque差不多都延续过来了，这里不再介绍。