【数据结构C#】栈和队列

栈和队列其实都是操作受限制的线性表。栈是只允许在一端进行插入或删除操作的线性表（先进后出）。队列是只允许在表的一端进行插入，另一端进行删除的线性表（先进先出）。

栈包含顺序栈，链栈 ，共享栈。

顺序栈 采用顺序存储

存储类型

#define MAXSIZE 50；
//存储结构
typedef struct{
	Elemtype data[MAXSIZE];//数据域，存放栈中元素
	int top;//栈顶指针
}SqStack;

栈顶指针：初始时为S.top=-1            栈顶元素：S.data[S.top]          栈长：S.top+1

基本操作如下 

//初始化操作
void InitStack(SqStack &S){
	S.top=-1;
}

//判断栈空 
bool StackEmpty(SqStack S){
	if(S.top==-1) return true;//栈空返回true
	return false;//栈不空返回false
}

//进栈 
//栈不满时，进栈指针加一，再送值到栈顶元素
//栈满条件：S.top=MAXSIZE-1; 
bool Push(SqStack &S,ElemType x){
	if(S.top!=MAXSIZE-1){
	data[++S.top]=x;
	return true;
	}
	return false;
}

//出栈 
//栈不满时，先取栈顶元素值，再将栈顶元素减1
bool Pop(SqStack &S,ElemType x){
	if(S.top!=MAXSIZE-1){
		x=data[S.top--];
		return true;
	}
	return false
}

//读栈顶元素 先进后出，从栈顶元素开始读取
//栈空条件：S.top==-1
bool GetTop(SqStack S,ElemType &x){
	if(S.top!=-1){
		x=S.data[S.top];
		return true;
	}
	return false;
}

  

链栈 采用链式存储

存储类型

//链栈的存储类型
typpedef struct{
    ElemType data;
	struct Linknode *next;
}*LiStack;

 基本操作参考链表，对于带头结点的链栈和不带头结点的链栈，操作会有所不同

 

共享栈

 

 

队列分为循环队列，链式队列，双端队列。 

 

循环队列 为了防止假溢出，将顺序队列臆造为一个环状的空间，即把存储队列元素的表从逻辑上视作一个环

#define MAXSIZE 100;
typedef struct{
	ElemType data[MAXSIZE];//数据域
	int front,rear;//队头指针和队尾指针
}SqQueue;

基本操作如下

//初始化
void INitQueue(SqQueue &Q){
	Q.rear=Q.front=0;//初始状态，即队空条件
}

//判断队空
bool isEmpty(SqQueue &Q,ElemType &x){
	if(Q.rear==Q.front) return true;
	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;//队尾指针加一
	//当队首指针Q.front=MAXSIZE-1时，再前进一个位置就自动到0，这可以利用取余运算来实现
	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;
}

 

链式存储 

实际上是一个带有队头指针和队尾指针的单链表，头指针指向队头结点，尾指针指向队尾结点

存储结构 

typedef struct{//链式队列结点
	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;
	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;
}

//出队
bool 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.front=Q.rear;
	//若队尾指针等于此结点，即原队列只有一个结点，删除后变空
	free(p);
	return true;
}

 

 

双端队列 双端队列是指两端都可以进行出队和入队操作的队列，其元素的逻辑结构任然是线性结构，将队列的两端分别称为前端和后端 

 在双端队列进队时，前端进的元素排列在队列中后端进的元素的前面，后端的元素排列在队列的中前端进的元素的后面

输出受限的双端队列：允许在一端进行插入和删除，但在另一端只允许插入的双端队列

输入受限的双端队列：允许在一端进行插入和删除，但在另一端只允许删除的双端队列

 

栈和队列都是特殊的线性表，但是要注意他们的空，满条件，以及具体的进，出操作。