栈与队列的实现

---

一.栈：

1.栈的概念及结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

2.栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。

// 下面是定长的静态栈的结构，实际中一般不实用，所以我们主要实现下面的支持动态增长的栈
typedef int STDataType;
#define N 10
typedef struct Stack
{
STDataType _a[N];
int _top; // 栈顶
}Stack;

Stack.h：

// 支持动态增长的栈
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;	   //栈顶，表示的为栈顶元素的下一位
	int capacity;  //容量 
}Stack;

//初始化栈 
void StackInit(Stack* ps);

//入栈 
void StackPush(Stack* ps, STDataType data);

//出栈 
void StackPop(Stack* ps);

//获取栈顶元素 
STDataType StackTop(Stack* ps);

//获取栈中有效元素个数 
int StackSize(Stack* ps);

//检测栈是否为空
bool StackEmpty(Stack* ps);

//销毁栈 
void StackDestroy(Stack* ps);

Stack.c

#include "Stack.h"
//初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);

	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

//入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);

	if (ps->capacity == ps->top)  //当栈顶与容量相等时，表示数组已经满了，需要扩容
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));  //扩容
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}

	ps->a[ps->top] = data;
	ps->top++;
}

//出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);

	ps->top--;  //出栈只需将栈顶坐标-1
}

//获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);

	return ps->a[ps->top - 1]; 
}

//获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);

	return ps->top;
}

//检测栈是否为空
bool StackEmpty(Stack* ps)
{
	assert(ps);
	
	return ps->top == 0;  //为空返回true，不为空返回false
}

//销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

上述代码中：

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;	   //栈顶，表示的为栈顶元素的下一个元素
	int capacity;  //容量 
}Stack;

//初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);

	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

因为我们在初始化时将top设置为0，但此时栈中并未有元素，而数组的首元素则是从0下标开始，在后面的入栈中，top在每一次入栈后都会+1，因此top的指向并非为栈顶元素，而是栈顶元素的下一位。
如果要使top指向栈顶元素，则在初始化时我们的top就不能初始化为0，而是-1，如下代码：

//初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);

	ps->a = NULL;
	ps->capacity = 0;
	ps->top = -1;
}

二.队列：

1.队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)
入队列：进行插入操作的一端称为队尾
出队列：进行删除操作的一端称为队头

2.队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

Queue.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>

typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* next;
	QDataType val;
}QNode;

//队列的结构 
typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;

//初始化队列 
void QueueInit(Queue* pq);

//队尾入队列 
void QueuePush(Queue* pq, QDataType x);

//队头出队列 
void QueuePop(Queue* pq);

//获取队列头部元素 
QDataType QueueFront(Queue* pq);

//获取队列队尾元素 
QDataType QueueBack(Queue* pq);

//获取队列中有效元素个数 
int QueueSize(Queue* pq);

//检测队列是否为空，如果为空返回非零结果，如果非空返回0 
bool QueueEmpty(Queue* pq);

//销毁队列 
void QueueDestroy(Queue* pq);

Queue.c

#include "Queue.h"

//初始化队列 
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}

//队尾入队列 
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}

	newnode->next = NULL;
	newnode->val = x;

	if (pq->ptail == NULL)  //队列中没有元素
	{
		pq->phead = pq->ptail = newnode;  
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}

//队头出队列 
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size != 0);  //出队列时，队列中元素个数不能为0

	if (pq->phead->next == NULL)  //队列中只剩一个元素
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else
	{
		QNode* next = pq->phead->next;  //先存储队头的下一个元素，再将队头出队列
		free(pq->phead);
		pq->phead = next;
	}

	pq->size--;
}

//获取队列头部元素 
QDataType QueueFront(Queue* pq)
{
	assert(pq);

	return pq->phead->val;
}

//获取队列队尾元素 
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	
	return pq->ptail->val;
}

//获取队列中有效元素个数 
int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

//检测队列是否为空
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->size == 0;  //为空返回true，不为空返回false
}

//销毁队列 
void QueueDestroy(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->phead;
	while (cur)  //循环释放链表
	{
		QNode* next = cur->next;
		free(cur);

		cur = next;
	}
	pq->phead = pq->ptail = NULL;  
	pq->size = 0;
}