数据结构——栈和队列（1）

一、栈的表示和操作的实现

（1）顺序栈

//顺序栈的存储结构
#define MAXSIZE 100//顺序栈存储空间的初始分配量 
typedef struct{
	SElemType *base;//栈底指针 
	SElemType *top;//栈顶指针 
	int stacksize;//栈可用最大容量 
}SqStack; 
//顺序栈的初始化
Status InitStack(SqStack &S){
	//构造一个空栈
	S.base=new SElemType[MAXSIZE];//为顺序栈动态分配一个最大容量为MAXSIZE的数组空间 
	if(!S.base)=exit(OVERFLOW);//存储分配失败 
	S.top=S.base;//top初始化为base，空栈 
	S.stacksize=MAXSIZE; //stack置为栈的最大容量MAXSIZE
	return OK; 
} 
//入栈
Status Push(SqStack &S,SElemType e){
	//插入元素e为新的栈顶元素 
	if(S.top-S.base==S.stacksize) return ERROR;//栈满 
	*S.top++=e;//元素e压入栈顶，栈顶指针加1 
	return OK;
} 
//出栈
Status Pop(SqStack &S,SElemType &e){
	if(S.top==S.base) return ERROR;//栈空 
	e= *--S.top;// 栈顶指针减1，将栈顶元素赋给e 
	return OK;
} 
SElemType GetTop(SqStack S){
	//返回S的栈顶元素，不修改栈顶指针 
	if(S.top!=S.base)//栈非空 
	return *(S.top-1);//返回栈顶元素的值，栈顶指针不变 
} 

(2)链栈

//链栈的存储结构
typedef struct StackNode{
	ElemType data;
	struct StackNode *next;
}StackNode,*LinkStack; 
//链栈的初始化
Status InitStack(LinkStack &S){
	//构造一个空栈S，栈顶指针置空 
	S=NULL;
	return OK;
} 
//入栈
Status Push(LinkStack &S,SElemType e){
	//在栈顶插入元素e 
	p=new StackNode;//生成新结点 
	p->data=e;//将新结点数据域置为e 
	p->next=S;//将新结点插入栈顶 
	S=p;//修改栈顶指针为p 
	return OK;
	
} 
//出栈 
Status Pop(LinkStack &S,SElemType &e){
	//删除栈顶元素，用e返回其值 
	if(S==NULL) return ERROR;//栈空
	e=S->data;//将栈顶元素赋给e 
	p=S;//用p临时保存栈顶元素空间，以备释放 
	S=S->next;//修改栈顶指针 
	delete p;//释放原栈顶元素的空间 
	return OK; 
}  
//取栈顶元素
SElemType GetTop(LinkStack S){
	//返回S的栈顶元素，不修改栈顶指针
	if(S!=NULL){//栈非空 
		return S->data;//返回栈顶元素的值，栈顶指针不变 
	} 
} 

二、队列的表示和操作的实现

（1）循环队列

//队列的顺序存储结构
#define MAXQSIZE 100//队列可能达到的最大长度 
typedef struct{
	QElemType *base;//存储空间基地址 
	int front;//头指针 
	int rear;//尾指针 
}SqQueue; 
//队空条件——Q.front==Q.rear;
//队满条件 ——(Q.rear+1)%MAXQSIZE=Q.front(rear+1会超过maxsize所以需求余)
 
//初始化
Status InitQueue(SqQueue &Q){
	//构造一个空队列Q 
	Q.base=new QElemType[MAXQAIZE];//为队列分配一个最大容量为MAXSIZE的数组空间 
	if(!Q.base)exit(OVERFLOW);//存储分配失败 
	Q.front=Q.rear=0;//尾指针和头指针置为0，队列为空 
	return OK;
}
//求队列长度
int QueueLength(SqQueue &Q){
	//返回Q元素的个数，即队列长度 
	return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
} 
//入队
Status EnQueue(SqQueue &Q,QElemType e){
	//插入元素e为Q的新的队尾元素 
	if((Q.rear+1)%MAXQSIZE==Q.front)return ERROR;//尾指针在循环意义上加1后等于头指针，表明队满 
	Q.base[Q.rear]=e;//新元素插入队尾 
	Q.rear=(Q.rear+1)%MAXQSIZE;//队尾指针加1 
	return OK;
} 
//出队 
Status DeQueue(SqQueue &Q,QELemType &e){
	//删除队头元素，用e返回其值 
	if(Q.front==Q.rear)return ERROR;//队空 
	e=Q.base[Q.front];//保存队头元素 
	Q.front=(Q.front+1)%MAXQSIZE;//队头指针加1 
	return OK;
} 
//取队头元素 
SElemType GetHead(SqQueue Q){
	//返回Q的队头元素，不修改队头指针
	if(Q.front!=Q.rear)//队列非空 
	{
		return Q.base[Q.front];//返回队头元素的值，队头指针不变 
	} 
} 

链队

//队列的链式存储结构
typedef struct QNode{
	QElemType data;
	struct QNode *next;
}QNode *QueuePtr;
typedef struct{
    QueuePtr front;//队头指针 
	QueuePtr rear;	//队尾指针 
}LinkQueue;
Status InitQueue(LinkQueue &Q){
	//构建一个空队列Q 
	Q.front=Q.rear=new QNode;//生成新结点作为头结点，队头和队尾指针指向此结点 
	Q.front->next=NULL;//头结点的指针域置空 
	return OK;
} 
//入队
Status EnQueue(LinkQueue &Q,QElemType e){
	//插入元素e为Q的新的队尾元素 
	p=new QNode;//为入队元素分配结点空间，用指针p指向 
	p->data=e;//将新结点数据域置为e 
	p->next=NULL;
	Q.rear->next=p;//将新结点插入到队尾 
	Q.rear=p;//修改队尾指针
	return OK;  
} 
//出队
Status DeQueue(LinkQueue &Q,QElemType &e){
	//删除Q的队头元素，用e返回其值 
	if(Q.rear==Q.front) return ERROR;//若队列空，则返回ERROR 
	p=Q.front->next;//p指向队头元素 
	e=p->data;//e保存队头元素的值 
	Q.front->next=p->next;//修改头指针 
	if(Q.rear==p) Q.rear=Q.front;//最后一个元素被删，队尾指针指向头结点
	delete p;//释放原队头元素的空间 
	return OK;
} 
//取队头元素
SElemType GetHead(LinkQueue Q)
{//返回Q的队头元素，不修改队头指针 
	if(Q.rear!=Q.front)//队列非空 
	{
		return Q.front->next->data;//返回队头元素的值，队头指针不变 
	}