数据结构之栈和队列的基本操作

1、顺序栈的栈顶初始化为-1时的基本操作：

#define Maxsize 50
typedef struct{
	ElemType data[Maxsize];    //存放栈中元素 
	int top;					//栈顶指针 
}SqStack; 

//初始化操作
void InitStack(SqStack &S)
{
	S.top=-1;
 } 
 
 //判断栈是否为空
 bool StackEmpty(SqStack S)
 {
 	if(S.top==-1)
 	return true;
 	else
 	return false;
}

//进栈
bool push(SqStack &S,ElemType x)
{
	if(S.top==Maxsize-1)   //进栈的第一步就是判断栈是否为满 
	{
		return false;
	}
	S.data[++S.top]=x;
	return true;
 } 
 
 //出栈
 bool pop(SqStack &S,ElemType &x)
{
	if(S.top==-1)   //出栈的第一步就是判断栈是否为空 
	{
		return false;
	}
	x=S.data[S.top--];
	return true;
 }  
 
 //读取栈顶元素
 bool GetTop(SqStack S,ElemType &x)
{
	if(S.top=-1)   //读栈的第一步就是判断栈是否为空 
	{
		return false;
	}
	x=S.data[S.top];
	return true;
 }  

2、顺序栈的栈顶初始化为0时的基本操作： 

#define Maxsize 50
typedef struct{
	ElemType data[Maxsize];    //存放栈中元素 
	int top;					//栈顶指针 
}SqStack; 

 //初始化操作
void InitStack(SqStack &S)
{
	S.top=0;
 } 
 
 //判断栈是否为空
 bool StackEmpty(SqStack S)
 {
 	if(S.top==0)
 	return true;
 	else
 	return false;
}

//进栈
bool push(SqStack &S,ElemType x)
{
	if(S.top==Maxsize)   //进栈的第一步就是判断栈是否为满 
	{
		return false;
	}
	S.data[S.top++]=x;
	return true;
 } 
 
 //出栈
 bool pop(SqStack &S,ElemType &x)
{
	if(S.top==0)   //出栈的第一步就是判断栈是否为空 
	{
		return false;
	}
	x=S.data[--S.top];
	return true;
 }  
 
 //读取栈顶元素
 bool GetTop(SqStack S,ElemType &x)
{
	if(S.top==0)   //读栈的第一步就是判断栈是否为空 
	{
		return false;
	}
	x=S.data[S.top-1];
	return true;
 }  

 3、不带头结点的链栈的基本操作： 

typedef struct Linknode{
	ElemType data;           //数据域 
	struct Linknode *next;    //指针域 
} *LiStack; 
 
 //初始化栈 
 bool InitStack(LiStack &S)
 {
 	S=(LiStack)malloc(sizeof(LiStack));
 	S->data=0;
 	S->next=NULL;
 }
 
 //入栈 
 bool PushStack(LiStack &S,ElemTyped x)
 {
 	LiStack p;
	p=(LiStack)malloc(sizeof(LiStack));
	p->data=x;
	p->next=S;
	S=p;
	return true;	
 }
 
 //出栈
 bool PopStack(LiStack &S,ElemTyped &x)
 {
 	LiStack p;
 	if(S==NULL)
	 	return false;
	p=S;
	x=S->data;
	S=S->next;
	free(p);
	return true;	
 }
 
 //判断栈是否为空
  bool StackEmpty(LiStack &S)
 {
 	if(S==NULL)
	return true;
	else
	return false;	
 } 

 4、带头结点的链栈的基本操作：  

typedef struct Linknode{
	ElemType data;           //数据域 
	struct Linknode *next;    //指针域 
} *LiStack; 
 
 //初始化栈 
 bool InitStack(LiStack &S)
 {
 	S=(LiStack)malloc(sizeof(LiStack));
 	S->data=0;
 	S->next=NULL;
 }
 
 //入栈 
 bool PushStack(LiStack &S,ElemTyped x)
 {
 	LiStack p;
	p=(LiStack)malloc(sizeof(LiStack));
	p->data=e;
	p->next=S->next;  //由于栈是LIFO的特性，故用头插法 
	S->next=p;
	return true;	
 }
 
 //出栈
 bool PopStack(LiStack &S,ElemTyped &x)
 {
 	LiStack p;
 	if(S->next==NULL)
	 	return false;
	p=S->next;
	x=S->data;
	S->next=p->next;   //只能在头部删除 
	free(p);
	return true;	
 }
 
 //判断栈是否为空
  bool StackEmpty(LiStack &S)
 {
 	if(S->next==NULL)
	return true;
	else
	return false;	
 } 

5、顺序存储的队列的基本操作：

 （1）队列的顺序存储

在队列的顺序存储中，附有两个指针，分别是front和rear，指针front指向队头元素，队尾指针rear指向队尾元素的下一个位置。

初始状态（队空条件）：Q.front=Q.rear=0；

进队操作：队不满时，先送值到队尾，再将队尾指针加1；

出队操作：队不空时，先取队头元素，再将队头指针加1；

 （1.1）循环队列

初始时(队空条件)： Q.front=Q.rear=0；

队首指针进1：Q.front=（Q.front+1）%Maxsize；

队尾指针进1：Q.rear=（Q.rear+1）%Maxsize；

队列长度：（Q.rear-Q.front+Maxsize）%Maxsize;

队满条件：（Q.rear+1)%Maxsize==Q.front; 或者Q.front=Q.rear&&Q.size==Maxsize;或者Q.front=Q.rear&&tag=1;

(2) 循环队列的基本操作：

#define Maxsize 50
typedef struct {
	ElemType data[Maxsize];      //存放队列元素
	int front,rear;             //存放队头和队尾指针 
}SqQueue; 

//初始化操作
void InitQueue(SqQueue &Q)
{
	Q.front=Q.rear=0;
 } 
 
 //判断队空
 bool Isempty(SqQueue Q)
 {
 	if(Q.front==Q.rear)
 	return true;
 	else
 	return false;
  } 
  
 //入队
 bool EnQueue(SqQueue &Q,ElemType x)
 {
 	if((Q.rear+1)%Maxsize==Q.front)
 	return false;
 	Q.data[Q.rear]=x;
 	Q.rear=(Q.rear+1)%Maxsize;
 	return true;
  } 
  
  //出队
bool DeQueue(SqQueue &Q,ElemType &x)
 {
 	if(Q.rear==Q.front)
 	return false;
 	x=Q.data[Q.front];
 	Q.front=(Q.front+1)%Maxsize;
 	return true;
  } 

 （3）带头结点的链队列的基本操作：

typedef struct LinkNode{
	ElemType data;                //存放队列结点 
	struct LinkNode *next;
}LinkNode; 

typedef struct{
	LinkNode *front,*rear;      //队列的队头和队尾指针 
}LinkQueue;
  
//初始化
void InitQueue(LinkQueue &Q)
{
	Q.front=Q.rear=(LinkNode *)malloc(sizeof(LinkNode));  //建立头结点
	Q.front->next=NULL; 
 } 
 
 //判队空
 bool Isempty(LinkQueue Q)
 {
 	if(Q.front==Q.rear)
 	return true;
 	else
 	return false;
  } 
  
//入队
void EnQueue(LinkQueue &Q,ElemType x)
{
	LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
	s->data=x;
	s->next=NULL;
	Q.rear->next=s;
	Q.rear=s;
 } 
 
 //出队
 void DeQueue(LinkQueue &Q,ElemType &x)
{
	if(Q.front==Q.rear)
	return false;
	LinkNode *p=Q.front->next;
	x=p->data;
	Q.front->next=p->next;
	if(Q.rear==p)   //判断是不是最后一个结点 
	{
		Q.rear=Q.front;
	} 
	free(p);
	return true; 
 } 

(4) 不带头结点的链队列的基本操作：

typedef struct LinkNode{
	ElemType data;                //存放队列结点 
	struct LinkNode *next;
}LinkNode; 

typedef struct{
	LinkNode *front,*rear;      //队列的队头和队尾指针 
}LinkQueue;
  
//初始化
void InitQueue(LinkQueue &Q)
{
	Q.front=Q.rear=NULL; 
 } 
 
 //判队空
 bool Isempty(LinkQueue Q)
 {
 	if(Q.front==NULL)
 	return true;
 	else
 	return false;
  } 
  
//入队
void EnQueue(LinkQueue &Q,ElemType x)
{
	LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
	s->data=x;
	s->next=NULL;
	if(Q.front==NULL)  //第一个结点 
	{
		Q.front=s;
		Q.rear=s;
	}
	else
	{
		Q.rear->next=s;
		Q.rear=s;	
	}
 } 
 
 //出队
 void DeQueue(LinkQueue &Q,ElemType &x)
{
	if(Q.front==NULL)
	return false;
	LinkNode *p=Q.front;
	x=p->data;
	Q.front=p->next;
	if(Q.rear==p)   //判断是不是最后一个结点 
	{
		Q.rear=Q.front=NULL;
	} 
	free(p);
	return true; 
 }