栈与队列

基于《大话数据结构》的学习笔记

一、栈

栈(Stack)是限定仅在表尾进行插入和删除操作的线性表。我们把允许插入和删除操作的一端称为栈顶*(top)，另一段称为栈底(bottom)*，不含任何数据元素的栈称为空栈。

栈又称为后进先出*(Last In First Out)的线性表，简称LIFO*结构。

1.栈的顺序储存结构

#define MAXSIZE 1000

typedef int Status;
typedef struct
{
	int data[MAXSIZE];
	int top;
}SqStack;

Status Push (SqStack *S, int e)
{
	if (S->top == MAXSIZE - 1)
		return ERROR;
	S->top ++;
	S->data[S->top] = e;
	return OK;
}

Status Pop (SqStack *S, int *e)
{
	if (S->top == -1) 
		return ERROR;
	*e = S->data[S->top];
	S->top --;
	return OK;
}

只需要对数组尾部（栈底）进行操作，O(1).

2.两栈共享空间

这对两个具有相同数据类型的栈的设计技巧。例如，买卖股票，买入和卖出可能相伴进行，一边买入一边卖出。

同一个数组，含有两个不同方向入栈的栈。将两个栈的栈顶向对。

typedef struct
{
	int data[MAXSIZE];
	int top1;
	int top2;
} SqDoubleStack;

Push 和 Pop

1.当第一个栈的栈顶 top1+1 ==第二个栈的栈顶top2, 此时栈满。

2.增加变量stackNumber来确定是哪个栈增加或删除元素。

Status Push (SqDoubleStack *S, int e, int stackNumber)
{
	if (S->top1 + 1 == S->top2)
		return ERROR;
	if (stackNumber == 1) 
		S->data[++S->top1] = e;		// 先位置增加在赋值。
	else if (stackNumber == 2)
		S->data[--S->top2] = e;
	return OK;
}

Status Pop (SqDoubleStack *S, int *e, int stackNumber)
{
	if (stackNumber == 1) {
		if (S->top1 == -1)
			return ERROR;
		*e = S->data[S->top1--];
	} 
	else if (stackNumber == 2) {
		if (S->top2==MAXSIZE)
			return ERROR;
		*e = S->data[S->top2++];
	}
	return OK;
}

3.链栈

通过单链表实现栈，优势同链表之于顺序表，即不必考虑栈的大小是否合适。

同时，链栈不需要头结点，或者说，头结点就是栈顶。

typedef int Status;
typedef struct StackNode
{
	int data;
	struct StackNode *next;
}StackNode, *LinkStackPtr;

typedef struct LinkStack
{
	LinkStackPtr top;
	int count;
}LinkStack;

Push 和 Pop

Status Push (LinkStack *S, int e)
{
	LinkStackPtr s = (LinkStackPtr)malloc(sizeof (StackNode));
	s->data = e;
	s->next = S->top;		//将新结点链接到栈的头部
	S->top = s;					//同时 s 成为新头部
	S->count ++;
	return OK;
}

Status Pop (LinkStack *S, int *e)
{
	LinkStackPtr p;
	if (StackEmpty (*S))
		return ERROR;
	*e = S->top->data;
	p = S->top;			// 接收栈顶元素以释放内存
	S->top = S->top->next;	// 栈顶变为下一结点
	free(p);
	S->count--;
	return OK;
}

4.基于栈的四则运算

将中序表达式转为后序表达式进行四则运算。

二、队列

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。

1.循环队列

我们把队列的这种头尾相接的顺序储存结构称为循环队列。

typedef struct
{
	int data[MAXSIZE];
	int front;			// 队头指针
	int rear;				// 队尾指针
} SqQueue;

Status InitQueue(SqQueue *Q) 
{
	Q->front = 0;
	Q->rear = 0;
	return OK;
}

把整个队列当作一个环，尾指针始终在头指针之前，当跑完一圈再次追上头指针时，队列已满。即此时有 ( rear + 1) % MAXSIZE == front

int QueueLength (SqQueue Q)
{
  /* 队列长度就是尾指针其后的头指针之间的距离。 */
	return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
}

入队和出队

Status EnQueue (SqQueue *Q, int e)
{
	if ( (Q->rear + 1 ) % MAXSIZE == Q->front)
		return ERROR;
	Q->data[Q->rear] = e;
	Q->rear = (Q->rear +1) % MAXSIZE; // 尾指针前移
	return OK;
}

Status DeQueue(SqQueue *Q, int *e)
{
	if (Q->front == Q->rear)
		return ERROR;
	*e = Q->data[Q->front];
	Q->front = (Q->front +1) % MAXSIZE; // 头指针亦前移
	return OK;
}

2.链队列

typedef struct QNode
{
	int data;
	struct QNode *next;
} QNode, *QueuePtr;

typedef struct
{
	QueuePtr front, rear;
} LinkQueue;

入队和出队

Status EnQueue (LinkQueue *Q, int e)
{
	QueuePtr s = (QueuePtr) malloc (sizeof(QNode));
//	if (!s)
//		exit (OVERFLOW);
	s->data = e;
	s->next = NULL;
	Q->rear->next = s;
	Q->rear = s;
	return OK;
} 

Status DeQueue (LinkQueue *Q, int *e)
{
	QueuePtr p;
	if (Q->front == Q->rear)
		return ERROR;
	p = Q->front->next;
	*e = p->data;
	Q->front->next = p->next;
	if (Q->rear == p)				// 如果 p 出队后队列空了
		Q->rear = Q->front;		// 则将rear指向头结点。
	free(p);
	return OK;
}