[数据结构与算法]数据结构——栈与队列

栈

栈是一种线性的存储结构，一般有顺序栈和链式栈两种存在形式。栈的最大特点为后进先出，只在栈顶进行操作。

如图，进栈的顺序是ABCD。但出栈时，只能从栈顶出栈，所以出栈顺序为DCBA。

顺序栈

我习惯于将顺序栈看作一个倒放的数组，栈底为数组的第一个元素。这样后续对于栈的操作便会好理解许多。

基本结构

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

基础操作

//栈的初始化
void InitStack(SqStack *S) {
	S->base = (Elemtype*)malloc(S->stacksize * sizeof(Elemtype));
	if (!S->base) printf("分配失败");
	S->top = S->base;
}

//栈是否为空的判断
bool JudgeStack(SqStack* S) {
	if (S->base == S->top)
		return true;//栈空则返回true
	else
		return false;
}

//栈的清空
void ClearStack(SqStack* S) {
	S->top = S->base;
}

//栈的销毁
void DestroyStack(SqStack* S) {
	if (!JudgeStack(S)) {
		free(S->base);
		S->base = 0;
		S->base = S->top = NULL;
	}
}

//入栈
void Push(SqStack* S, Elemtype e) {
	if (S->top - S->base == S->stacksize) {
		//栈满时直接扩大栈的内存
		S->base = (Elemtype*)realloc(S->base, S->stacksize * sizeof(Elemtype));
		S->top = S->base + S->stacksize;
		S->stacksize *= 2;
	}
	*S->top = e;
	S->top++;
}

//出栈并返回栈顶元素
bool Pop(SqStack* S, Elemtype *e) {
	if (S->top == S->base) {
		return false;
	}
	S->top--;
	*e = *S->top;
}

链式栈

链式栈则是一种基于链表操作的栈。相比于常见的单链表，链式栈不过是只能从链表的一端进行插入和删除的操作罢了，并没有其他神秘的点。由于队列部分有链队的详细操作，二者结合便可大概知道链式栈的模样，在这里就不详细列出其操作。

队列

与栈相比，队列的特点是先进先出，也可理解为头进尾出。像这样👇

事实上，在下面的具体操作中，我们选择了头进尾出的方式。

顺序队列

由于顺序队列会涉及“假溢出”的问题以及解决方法，我们留到下期再谈。

链式队列

基本结构

由于链式队列与链表相似，也就是说它也需要结点，所以我们定义了两个结点，一个代表结点一个表示队列

typedef struct Qnode {
	Elemtype data;
	struct Qnode* next;
}Qnode;
typedef struct LinkQueue {
	Qnode* front;
	Qnode* rear;
}LinkQueue;

基本操作

//队列的初始化
void InitQueue(LinkQueue* Q) {
//很明显地看出，我们选择了带头结点的链表，使得后续判空操作更方便
	Q->front = Q->rear = (Qnode*)malloc(sizeof(Qnode));
	Q->front->next = NULL;
}

//队列是否为空的判断
bool JudgeQueue(LinkQueue* Q) {
	if (Q->front == Q->rear)
		return true;
	else
		return false;
}


//队列的销毁
void DestroyQueue(LinkQueue* Q) {
	Qnode* p = Q->front;
	while (Q->front) {
		p = Q->front->next;
		free(Q->front);
		Q->front = p;
	}
	Q->rear = Q->front = NULL;
}

//入队
void Push(LinkQueue* Q, Elemtype e) {
	Qnode* p = (Qnode*)malloc(sizeof(Qnode));
	if (!p) {
		exit(1);
	}
	p->data = e;
	p->next = NULL;
	Q->rear->next = p;
	Q->rear = p;
}

//出队
bool Pop(LinkQueue* Q, Elemtype* e) {
	if (Q->front == Q->rear) {
		return false;
	}
	Qnode* p = Q->front->next;
	*e = p->data;
	Q->front->next = p->next;
	if (Q->rear == p) {
		Q->rear = Q->front;
		//当只剩下最后一个元素取出时，做特殊处理
	}
	free(p);
}