STL （vector 栈 队列）

目录

vector容器

vector容器用法：

队列  queue容器

C++ (使用stl容器 实现队列):

queue容器的用法：

C语言 实现队列：

队列--顺序结构

队列--链式结构

栈  stack容器

C++ (使用stl容器 实现栈):

stack容器的用法

C语言 实现栈

栈--顺序结构

栈--链式结构

---

C++STL一般声明原则：容器类型<变量类型>名称

• vector容器

概念：相当于一个“变长数组”

库：#include<vector>

法一： 
	vector<int>vec;//声明
	for(int i=0;i<5;i++){
		int temp;
		cin>>temp;
		vec.push_back(temp);//从vector末尾加入一个元素；;
	} 
	cout<<vec.size() ;
	cout<<"首元素:"<<vec.front ()<<"\n尾元素："<<vec.back()  ;

#include<algorithm> //sort库
法二： 
	vector<int>vec(5 );//声明 长度为5的数组vec
	for(int i=0;i<5;i++){
		cin>>vec[i];
	}
	sort(vec.begin() ,vec.end() ); //排序
	
	for(int i=0;i<5;i++){
		cout<<vec[i]<<" ";
	}

• vector容器用法：

vec.begin(),vec.end()	返回vector的首、尾迭代器
vec.front(),vec.back()	返回vector的首、尾元素
vec.push_back()	从vector末尾加入一个元素
vec.size()	返回vector当前的长度（大小）
vec.pop_back()	从vector末尾删除一个元素
vec.empty()	返回vector是否为空，1为空、0不为空
vec.clear()	清空vector

---

• 队列  queue容器

队列：先进先出

• C++ (使用stl容器 实现队列):

库：#include<queue> 

queue容器的用法：

q.front(),q.back()	返回queue的首、尾元素
q.push()	从queue末尾加入一个元素
q.size()	返回queue当前的长度（大小）
q.pop()	从queue末尾删除一个元素
q.empty()	返回queue是否为空，1为空、0不为空

---

• C语言 实现队列：

队列--顺序结构

//顺序结构
#include<stdio.h>
#include<stdlib.h> 
struct seqqueue{
	int MAXNUM;
	int f,r;
	int *q;
};
typedef struct seqqueue *pseqqueue;
int main()
{
	pseqqueue create_seq(int m);     //建一个空队列
	int isempty_seq(pseqqueue paqu);     //判断是否为空队列
	void input_seq(pseqqueue paqu,int x);     //入队
	void chuduitou(pseqqueue paqu);      //出队
	int quduitou_seq(pseqqueue paqu);    //取队列首元素
	pseqqueue a;
	int m,n,i,x;
	printf("输入最大容量：");
	scanf("%d",&m);
	a=create_seq(m); 
	n=isempty_seq(a);
	if(n==1) printf("空队\n");
	else printf("不是空队\n");
	printf("入队总数：");scanf("%d",&m);
	for(i=0;i<m;i++){
		printf("入队元素：");
		scanf("%d",&x); 
		input_seq(a,x);
	}
	printf("对头为：%d\n",quduitou_seq(a));
	chuduitou(a);printf("对头删除成功！\n");
	printf("对头为：%d\n",quduitou_seq(a));
	return 0;
 } 
 
pseqqueue create_seq(int m)
{
	pseqqueue paqu=(pseqqueue)malloc(sizeof(struct seqqueue));
	if(paqu!=NULL){printf("创建成功！\n");
	paqu->q =(int *)malloc(sizeof(int)*m);
		paqu->f =0;
		paqu->r =0;
		paqu->MAXNUM =m;
	}else{
		printf("创建失败！\n");
	}
	return paqu;
}

int isempty_seq(pseqqueue paqu)
{
	return (paqu->f ==paqu->r );
}

void input_seq(pseqqueue paqu,int x)
{
	if((paqu->r+1)%(paqu->MAXNUM )==paqu->f  ) printf("满队\n");
	else{
		paqu->q[paqu->r]=x;
		paqu->r=(paqu->r+1)%(paqu->MAXNUM ); 
	}
}

void chuduitou(pseqqueue paqu){
	if(paqu->f ==paqu->r ) printf("空队\n");
	else {
		paqu->f =(paqu->f+1)%(paqu->MAXNUM );
	} 
}

int quduitou_seq(pseqqueue paqu)
{
	if(paqu->f==paqu->r )printf("空队\n");
	else{
		return (paqu->q[paqu->f ]);
	}
}

队列--链式结构

//链式结构
#include<stdio.h>
#include<stdlib.h>
struct node;
typedef struct node *pnode;
struct node{
	int info;
	pnode link;
};

struct linkqueue{
	pnode f;
	pnode r;
};
typedef struct linkqueue *plinkqueue;

int main()
{
	 plinkqueue create_link(void);    //建一个空队列
	  int isempty (plinkqueue plqu);    //判断是否为空队列
	   void rudui(plinkqueue plqu,int x);    //入队
	    void chudui(plinkqueue plqu);    //出队
	     int quduitou(plinkqueue plqu);    //取队列首元素
	  plinkqueue a;
	  int m,n,x,i;
	  a=create_link(); 
	  m=isempty (a);
	  if(m==1)printf("空队\n");
	  else printf("不是空队\n");
	  printf("入队总数：");scanf("%d",&n);
	  for(i=0;i<n;i++)
	  {
	  	printf("入队元数：");scanf("%d",&x);
	  	rudui(a,x);
	  }
	   printf("对头为：%d\n",quduitou(a));
	   chudui(a);
	   printf("对头出队成功\n");
	   printf("对头为：%d\n",quduitou(a));
	return 0;
 } 
 
 plinkqueue create_link(void)
 {
 	plinkqueue plqu=(plinkqueue)malloc(sizeof(struct linkqueue));
 	if(plqu!=NULL){
 		plqu->f =NULL;
 		plqu->r =NULL;
		  printf("创建成功\n");
	 }else printf("创建失败\n");
	 return plqu;
 }
 
 int isempty (plinkqueue plqu)
 {
 	return(plqu->f==NULL);
 }
 
 void rudui(plinkqueue plqu,int x)
 {
 	pnode p=(pnode)malloc(sizeof(struct node));
 	if(p==NULL){printf("out of space\n");
	 }else{
	 	p->info =x;
	 	p->link =NULL;
	 	if(plqu->f ==NULL){
	 		plqu->f =p;
		 }else plqu->r->link =p;
		 plqu->r =p;
	 }
 }
 
 void chudui(plinkqueue plqu)
 {
 	pnode p;
 	if(plqu->f==NULL) printf("空队\n");
 	else{
 		p=plqu->f;
 		plqu->f=p->link ;
 		free(p);
	 }
 }
 
 int quduitou(plinkqueue plqu)
 {
 	if(plqu->f ==NULL)printf("空队\n");
 	else {
 		return (plqu->f->info );
	 }
 }

---

• 栈  stack容器

栈概念：先进后出

• C++ (使用stl容器 实现栈):

库：#include<stack>

stack容器的用法

st.top()	返回stack的栈顶元素
st.push()	从stack栈顶加入一个元素
st.size()	返回stack当前的长度（大小）
st.pop()	从stack栈顶弹出一个元素
st.empty()	返回stack是否为空，1为空、0不为空

---

• C语言 实现栈

栈--顺序结构

​
//顺序结构
#include<stdio.h>
#include<stdlib.h> 
struct seqstack{
	int MAXNUM;
	int t;
	int *s; 
};
typedef struct seqstack *pseqstack;
int main()
{
	pseqstack createnullstack_seq(int m);
	int isnullstack_seq(pseqstack pastack);
	void push_seq(pseqstack pastack,int x);
	void pop_seq(pseqstack pastack);//删除栈顶元素 
	int top_seq(pseqstack pastack);//输出栈顶元素 
	
	pseqstack a;
	int i,m,n,x;
	printf("请输入栈中最大元素个数：");
	scanf("%d",&m); 
	a=createnullstack_seq(m);
	n=isnullstack_seq(a);
	if(n==1)printf("是空栈！\n");
	else printf("不是空栈!\n");
	
	printf("输入要入栈的个数：");
	scanf("%d",&n);printf("请输入入栈元素：");
	for(i=0;i<n;i++)
	{
	scanf("%d",&x);
		push_seq(a,x);
	}
	x=top_seq(a);
	printf("栈顶元素为：%d\n",x);
	
	pop_seq(a);
	
	x=top_seq(a);
	printf("栈顶元素为：%d\n",x);
	
	
	return 0;
}

pseqstack createnullstack_seq(int m)
{
	pseqstack pastack=(pseqstack)malloc(sizeof(struct seqstack));
	if(pastack!=NULL){
		pastack->s =(int *)malloc(sizeof(int)*m);
		if(pastack->s ){
			pastack->MAXNUM =m;
			pastack->t =-1;
			return pastack;
		}
		else free(pastack);
	}
	printf("out of space!\n");
	return NULL;
}

int isnullstack_seq(pseqstack pastack)
{
	return (pastack->t ==-1);	
}

void push_seq(pseqstack pastack,int x)
{
	if(pastack->t <pastack->MAXNUM ){
		pastack->t =pastack->t +1;
		pastack->s[pastack->t ] =x;
	}
	else printf("栈已满，不能入栈\n");
}

void pop_seq(pseqstack pastack)//删除栈顶元素 
{
	if(pastack->t ==-1)printf("栈为空！\n");
	else 
	{
	pastack->t =pastack->t -1;
	printf("栈顶删除成功！\n");
	}
}

int top_seq(pseqstack pastack)
{
	int a;
	if(pastack->t ==-1)printf("栈为空！\n");
	else {
		a=pastack->s[pastack->t ];
		return a;
	}
}

​

栈--链式结构

//链式结构
#include<stdio.h>
#include<stdlib.h>
struct lnode; 
typedef struct lnode *pnode;
struct lnode{
	int info;
	pnode link;
};

struct linkstack{
	pnode top;
};
typedef struct linkstack *plinkstack;

int main()
{
	plinkstack createemptystack_link(void);
	int isemptystack_link(plinkstack plstack);
	int push_link(plinkstack plstack,int x);
	void pop_link(plinkstack plstack);
	int top_link(plinkstack plstack);
	
	int m,n,x,i;
	plinkstack a;
	a=createemptystack_link();
	m=isemptystack_link(a);
	if(m==1) printf("是空栈！\n");
		else printf("不是空栈！\n");
	printf("请输入入栈数：");
	 scanf("%d",&n);
	for(i=0;i<n;i++){
		printf("输入栈元素：");
		scanf("%d",&x) ;
		push_link(a,x);
	}  

		m=top_link(a);
    	printf("\n栈顶元素：%d",m);
    	printf("\n\n****************\n\n");
	pop_link(a);
	 printf("删除栈顶元素成功\n");
    	m=top_link(a);
    	printf("\n栈顶元素：%d",m);
	return 0;
 } 

plinkstack createemptystack_link(void){
	plinkstack plstack=(plinkstack)malloc(sizeof(struct linkstack));
	if(plstack){
		plstack->top =0;
	}
	else printf("创建失败！"); 
	
	return plstack;
}

int isemptystack_link(plinkstack plstack){
	return (plstack->top ==NULL);
}

int push_link(plinkstack plstack,int x){
	pnode p=(pnode)malloc(sizeof(struct lnode));
	if(p==NULL) printf("out of space!\n");
	else {
		p->info =x;
		p->link =plstack->top ;
		plstack->top=p;
	}
}

void pop_link(plinkstack plstack){//出栈即删除； 
	pnode p;
	if(isemptystack_link(plstack)==1) printf("空栈\n");
	else{
		p=plstack->top; 
		 //printf("%d",p->info );
		 plstack->top=p->link;
		 free(p);
	}
}

int top_link(plinkstack plstack){
	pnode p;
	if(isemptystack_link(plstack)==1) printf("空栈\n");
	else {
		/*p=plstack->top ;
		printf("栈顶元素：%d",p->info );*/
		return(plstack->top->info ); 
	}
	
}

---