c++中一些头文件的用法

 

#include <algorithm>中sort的一般用法：

  1、sort函数的时间复杂度为n*log2(n)，执行效率较高。

  2、sort函数的形式为sort（first，end，method）//其中第三个参数可选。

  3、若为两个参数，则sort的排序默认是从小到大

#include<iostream>    #include<algorithm>    using namespace std;    int main()    {      int a[10]={9,6,3,8,5,2,7,4,1,0};      for(int i=0;i<10;i++)      cout<<a[i]<<endl;      sort(a,a+10); //可以看出，两个参数为均地址,a为起始，a+10为结束位置      for(int i=0;i<10;i++)      cout<<a[i]<<endl;      return 0;    }  

若为三个参数，则需要写一个cmp函数（此名称cmp可变），用于判断是从小到大排序还是从大到小排序：

bool cmp(int a,int b);

{

    return a>b;

}

sort（a，a+10,cmp）;

也可以利用结构体中的int型数进行排序

#include <iostream>
#include <queue>
using namespace std; //这几个头文件必不可少

int main()
{
queue<类型（如int）> q; //使用前需定义一个queue变量，且定义时已经初始化
while(!q.empty()) q.pop(); //重复使用时，用这个初始化
q.push(1); //进队列
q.pop(); //出队列
int v=q.front(); //得到队首的值
int s=q.size(); //得到队列里元素个数

return 0;
}

其它概述：

使用queue之前，要先利用构造函数一个队列对象，才可以进行元素的入队，出队，取队首和队尾等操作；

（1）.queue（） queue<int> q； 或者 queue<int>Q[10000];

(2).queue(const queue&) 复制构造函数 例如：用一行代码利用queue对象q1，创建一个以双向链表为底层容器的queue对象q2queue<int,list<int>>q1;queue<int,list<int>>q2(q1);

(3).元素入队 函数为：push（）例如：q.push(3),意思是将3入队 ,注意队列的大小不预设

（4）.元素出队 函数为：pop（）例如：q.pop()

(5)。取对头元素 函数为：front()

(6)，取队尾元素 函数为：back()

(7)。判断对空 函数为:empty()

(8)。队列的大小 函数为：size（）返回队列的当前元素的个数9.如何实现固定大小的queue队列 在每一次元素入队列前都判断当前的队列是否满，用双向链表做queue 的底层容器可以实现例如：

1. #include<iostream>

2. #include<list>

3. #include<queue>

4. using namespace std;

5. #define QUEUE_SIZE 50 //固定大小为50

6. int main()

7. {

8. queue<int,list<int>> q;

9. if(q.size<QUEUE_SIZE)q.push(51);

10. if(q.size<QUEUE_SIZE)q.push(36);

11. if(q.size<QUEUE_SIZE)q.push(28);

12. while(!q.empty())

13. {

14. cout<<q.front()<<endl; //打印51 36 28q.pop();

15. //出队}return 0;

16. }

code:

1. #include<stdio.h>

2. #include<queue>

3. #include<string.h>

4. using namespace std;

5. int main()

6. {

7. register int i,j;

8. int m,n;

9. char c[6];

10. int x,y;

11. while(scanf("%d%d",&n,&m)!=EOF)

12. {

13. queue<int>Q[10000];

14. for(i=0;i<m;i++) {

15. scanf("%s",&c);

16. if(strcmp(c,"INIT")==0)

17. {

18. for(j=1;j<=n;j++)

19. {

20. while(!Q[j].empty())

21. Q[j].pop();

22. }

23. continue;

24. }

25. if(strcmp(c,"PUSH")==0)

26. {

27. scanf("%d%d",&x,&y);

28. Q[x].push(y);

29. continue;

30. }

31. if(strcmp(c,"POP")==0)

32. {

33. scanf("%d",&y);

34. if(Q[y].empty())

35. {

36. printf("NULLn");

37. continue;

38. }

39. else

40. printf("%dn",Q[y].front());

41. Q[y].pop();

42. }

43.

44. }

45. }

46. return 0;

47. }

C++ Stack（堆栈） 是一个容器类的改编，为程序员提供了堆栈的全部功能，——也就是说实现了一个先进后出（FILO）的数据结构。

c++ stl栈stack的头文件为: 

#include <stack> 

c++ stl栈stack的成员函数介绍

操作 比较和分配堆栈

empty() 堆栈为空则返回真

pop() 移除栈顶元素

push() 在栈顶增加元素

size() 返回栈中元素数目

top() 返回栈顶元素

栈（stack）是限制插入和删除只能在一个位置上进行的线性表，该位置在表的末端，叫做栈顶。添加元素只能在尾节点后添加，删除元素只能删除尾节点，查看节点也只能查看尾节点。添加、删除、查看依次为入栈（push）、出栈（pop）、栈顶节点（top）。形象的说，栈是一个先进后出（LIFO）表，先进去的节点要等到后边进去的节点出来才能出来。

如图1，是一个栈的形象图，top指针指向的是栈顶节点，所以我们可以通过top访问到2节点，但是0和1节点由于先于2进入这个表，所以是不可见的。如果把0节点当做头节点，2节点当做尾节点，那么栈限制了访问权限，只可以访问尾节点。

如图2，当添加一个节点3的时候，只能在栈顶节点，也就是尾节点后添加，这样3节点变成了栈顶，2节点变成了不可见节点，访问的时候只能访问到3节点。入栈时限制了插入地址，只能在栈顶添加节点。

当我们执行出栈的命令时，图2的栈顶元素是3节点，删除的时候只能允许删除栈顶的元素，这样子3节点被删除，top指向删除后的栈顶2节点，如图3所示。

栈有两种是实现结构，一种是顺序存储结构，也就是利用数组实现，一种是链式存储结构，可以用单链表实现。数组实现栈很简单，用一个下标标记top来表示栈顶，top==-1时，栈空，top==0时，表示栈里只有一个元素，通过访问top为下标的数组元素即可。出栈top自减，入栈top自加就OK了。

单链表实现栈要比单链表的实现简单点。我们通过在表的尾端插入来实现push，通过删除尾节点来实现pop，获取尾节点的元素来表示top。我修改了链表那一章的单链表代码，把头节点当做栈顶节点，实现了一个简单的栈模板，仅供学习所用。代码会不定时更新。代码下载