栈和队列的实现（顺序结构和链式结构）

本节实现的两个数据结构，在实际生活中有不少的应用场景，手写可以加强我们对它们的理解。同时栈也是递归实现的抽象模型，递归应当着重掌握。顺序队列中实现循环的部分应当着重掌握，有点类似于约瑟夫环。

#include"stdio.h"
#include"stdlib.h"  //该文件中包含malloc和free()
#define MAXSIZE 100
#define MAXQSIZE 100
//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
//Status是函数的类型，其值是函数结果状态代码
typedef int Status;
typedef char SElemType;
typedef char QElemType;

//顺序栈
//顺序栈的数据类型
typedef struct
{
	SElemType *top;   //栈顶指针
	SElemType *base;   //栈底指针
	int stacksize;     //栈的容量  top-base可以表示栈中有多少个元素
}SqStack;

//顺序栈的初始化
Status InitStack(SqStack &S)
{
	S.base = (SElemType *)malloc(sizeof(SElemType));
	if (!S.base) return ERROR; //分配内存空间失败
	S.top = S.base;
	S.stacksize = MAXSIZE;
	return OK;
}

//判断顺序栈是否为空
Status StackEmpty(SqStack S)
{
	if (S.top == S.base) return TRUE;
	else return FALSE;
}

//求顺序栈的长度
int StackLength(SqStack S)
{
	return S.top - S.base;
}

//清空顺序栈
Status ClearStack(SqStack &S)
{
	if (S.base) S.top = S.base;
	return OK;
}

//销毁顺序栈
Status DestroyStack(SqStack &S)
{
	if (S.base)
	{
		free(S.base);
		S.stacksize = 0;
		S.top = S.base = NULL;
	}
	return OK;
}

//顺序栈入栈
Status Push(SqStack &S,SElemType e)
{
	if (S.top - S.base == S.stacksize)
	{
		return ERROR;
	}
	*S.top++ = e;
	return OK;
}

//顺序栈出栈
Status Pop(SqStack &S,SElemType &e) 
{
	if (S.top == S.base) return ERROR;
	e = *--S.top;  //用e接收弹出的值
	return OK;
}

//链栈
//链栈元素数据类型
typedef struct StackNode
{
	SElemType data;
	struct StackNode * next;
}StackNode,*LinkStack;  //链栈中头指针指向栈顶元素，指针方向从栈顶指向栈底
                        //链栈没有头结点，空栈的时候头指针指向空

//判断链栈是否为空
Status StackEmpty(LinkStack S)
{
	if(S == NULL) return TRUE;
	else return FALSE;
}

//链栈上的入栈
Status Push_L(LinkStack &S,SElemType e)
{
	StackNode *p = (StackNode *)malloc(sizeof(StackNode));
	p->data = e;
	p->next = S;  //指针方向从栈顶指向栈底
	S = p;  //栈顶指针更新
	return OK;
}

//链栈上的出栈
Status Pop_L(LinkStack &S, SElemType &e)
{
	if (S == NULL) return ERROR;
	e = S->data;
	StackNode *p = S;
	S = S->next;
	free(p);
	return OK;
}

//取栈顶元素
SElemType GetTop(LinkStack S)
{
	if (S != NULL) return S->data;
}

//顺序队列
typedef struct
{
	QElemType *base;
	int front;  //头指针
	int rear;   //尾指针
}SqQueue;

//顺序循环队列的初始化
Status InitQueue(SqQueue &Q)
{
	Q.base = (QElemType *)malloc(sizeof(QElemType)*MAXQSIZE);
	if (!Q.base) exit(OVERFLOW);
	Q.front = Q.rear = 0;
	return OK;
}

//求顺序循环队列的长度
int QueueLength(SqQueue Q)
{
	return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}

//循环队列的入队操作
Status EnQueue(SqQueue &Q,QElemType e)
{
	if ((Q.rear + 1) % MAXQSIZE == Q.front) return ERROR;
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear + 1) % MAXQSIZE;
	return OK;
}

//循环队列出队操作
Status DeQueue(SqQueue &Q, QElemType &e)
{
	if (Q.front == Q.rear) return ERROR;
	e = Q.base[Q.front];
	Q.front = (Q.front + 1) % MAXQSIZE;
}

//取队头元素
QElemType GetHead(SqQueue 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;  //链式队列,具有头结点Q.front

//链式队列的初始化
Status InitQueue(LinkQueue &Q)
{
	Q.front = Q.rear = (QNode *)malloc(sizeof(QNode));
	if (!Q.front) exit(OVERFLOW);
	Q.front->next = NULL;
	return OK;
}

//链式队列的销毁
Status DestroyQueue(LinkQueue &Q)
{
	QNode *p;
	while (Q.front)
	{
		p = Q.front->next;
		free(p);
		Q.front = p;
	}
	return OK;
}

//链式队列入队
Status EnQueue(LinkQueue &Q, QElemType e)
{
	QNode *p = (QNode *)malloc(sizeof(QNode));
	if (!p) exit(OVERFLOW);
	p->data = e;
	p->next = NULL;
	Q.rear->next = p;
	Q.rear = p;
	return OK;
}

//链式队列出队
Status DeQueue(LinkQueue &Q, QElemType &e)
{
	if (Q.front == Q.rear) return ERROR;
	QNode *p = (QNode *)malloc(sizeof(QNode));
	p = Q.front->next;
	e = p->data;
	Q.front->next = p->next;
	if (Q.rear == p) Q.rear = Q.front;
	free(p);
	return OK;
}

int main()
{
	SqStack S;
}