数据结构——栈和队列

栈和队列是两种重要的线性结构，可以视作操作受限的线性表。

一、 栈

定义： 栈是限定仅在表尾进行插入和删除操作的线性表。表尾端称为栈顶，表头端称为栈底。

特点：后进先出。LIFO

栈的顺序存储表示：

typedef struct{
	SElemType *base;
	SElemType *top;
	int stacksize;
}SqStack;

初始化栈：

Status InitStack(SqStack &S)
{
	S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
	if(!S.base)
		exit(OVERFLOW);
	S.top = S.base;
	S.stacksize = STACK_INIT_SIZE;
	return OK;
}

获取栈顶元素：

Status GetTop(SqStack S, SElemType &e)
{
	if(S.top == S.base)
		return ERROR;
	e = *(S.top-1);
	return OK;
}

插入元素：

Status Push(SqStack &s, SElemType e)
{
	if(S.top - S.base >= S.stacksize)
	{
		S.base = (SElemType *)realloc(S.base, (S.stacksize + INCREMENT) * sizeof(SElemType));
		if(!S.base)
			exit(OVERFLOW);
		S.top = S.base + S.stacksize;
		S.stacksize += INCREMENT;
	}
	*S.top = e;
	S.top++;
	return OK;
}

删除元素：

Status Pop(Stack &S, SElemType &e)
{
	if(S.base == S.top)
		return ERROR;
	e = *(--S.top);
	return OK;
}

以上是栈的顺序存储表示，其实栈还可以用链式结构来存储表示。类似于链表，表头作为栈顶，表尾作为栈底。

二、栈的应用

栈具有后进先出的特性，其应用有：

数制转换，括号匹配，行编辑器，迷宫求解问题，表达式求值，递归……

三、 队列

与栈不同的是，队列是一种先进先出的线性表。一端进行插入、一端进行删除。允许插入的一端叫做队尾，允许删除的一端叫做队头。

队列 的链式存储表示：

typedef struct QNode{
	QElemType data;
	struct QNode *next;
}QNode, *QueuePtr;
typedef struct{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;

初始化队列：

Status InitQueue(LinkQueue &Q)
{
	Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
	if(!Q.front)
		exit(OVERFLOW);
	Q.front->next = NULL;
	return OK;
}

销毁队列：

Status DestroyQueue(LinkQueue &Q)
{
	while(Q.front)
	{
		Q.rear = Q.front->next;
		free(Q.front);
		Q.front = Q.rear;
	}
	return OK;
}

入队列：

Status EnQueue(LinkQueue &Q, QElemType e)
{
	p = (QueuePtr)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;
	p = Q.front->next;
	Q.front->next = p->next;
	e = p->data;
	if(Q.rear == p)
		Q.rear = Q.front;
	free(p);
	return OK;
}

队列也可以用顺序存储结构，为了更有效地利用存储空间，可以采用循环队列的存储结构。

循环队列：

typedef struct{
	QElemType *base;
	int front;
	int rear;
}SqQueue;

初始化循环队列：

Status InitQueue(SqQueue &Q)
{
	Q.base = (QElemType *)malloc(INIT_STACK_SIZE * sizeof(QElemType));
	if(!Q.base)
		exit(OVERFLOW);
	Q.front = Q.rear = 0;
	return OK;
}

返回队列长度：

int QueueLength(SeQueue Q)
{
	return (Q.rear - Q.front + INIT_STACK_SIZE) % INIT_STACK_SIZE;
}

入队列：

Status EnQueue(SqQueue &Q, QElemType e)
{
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear + 1)%INIT_STACK_SIZE;
	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)%INIT_STACK_SIZE;
	return OK;
}