初识数据结构——栈和队列（C语言）

前言：

        在上篇文章中，我们简单介绍了两种基础数据结构——顺序表和单链表，今天我们就再来介绍两种简单的数据结构——栈和队列

1.栈

        1.1栈的基本概念

1. 栈（Stack）是只允许在一端进行插入或删除的线性表
2. 栈顶：线性表中允许进行插入或删除的一端
3. 栈底：线性表的另一端
4. 栈是一种后进先出的线性表

物理结构如下图

1.2栈的实现

        其实栈和我们前面说的顺序表结构差不多，区别就是栈只能在一端进行插入删除，所以我们话不多说，直接开始实现以下常用接口

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);

        （1）栈的初始化

// 初始化栈 
void StackInit(Stack* ps) {
	assert(ps);
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;

}

        （2）入栈出栈 

// 入栈 
void StackPush(Stack* ps, STDataType data) {
	assert(ps);
	if (ps->_top == ps->_capacity) {
        //由于我们初始化时没有给栈内存，所以我们这里使用三目操作符来开辟一下
		int new_capacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->_a, new_capacity * sizeof(STDataType));
		if (tmp == NULL) {
			perror("realloc fail");
			return;
		}
		ps->_a = tmp;
		ps->_capacity = new_capacity;
	}
	ps->_a[ps->_top] = data;
	ps->_top++;
	
}
// 出栈 
void StackPop(Stack* ps) {
	assert(ps);
	ps->_top--;
}

        （3）取栈顶元素，获取栈中有效元素个数

// 获取栈顶元素 
STDataType StackTop(Stack* ps) {
	assert(ps);
	assert(ps->_top > 0);
	return ps->_a[ps->_top-1];
}
// 获取栈中有效元素个数 
int StackSize(Stack* ps) {
	assert(ps);
	return ps->_top;
}

        （4）栈的判空和销毁

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps) {
	assert(ps);
	return ps->_top == 0;
}
// 销毁栈 
void StackDestroy(Stack* ps) {
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_top = ps->_capacity = 0;
}

2.队列

        2.1队列的基本概念

1. 和栈恰恰相反，队列（queue）是只允许在一段进行插入，而在另一端进行删除的结构
2. 队列是一种先进先出的线性表
3. 对尾：允许进行插入的一端
4. 队头：允许进行删除的一端
5. 队列的物理结构如下图

         2.2队列的实现

        队列可以用数组（顺序表）来实现，也可以用链表来实现，上文中栈的实现我们使用了顺序表，那队列我们就用链表来实现以下常用接口吧：

typedef int QDataType;

typedef struct QueNode {
	QDataType val;
	struct QueNode* next;
}Node;
typedef struct Queue {
	Node* phead;//指向队头的指针
	Node* ptail;//指向队尾的指针
	int size;//用于记录队列中的数据个数
}Queue;
//队尾插入
void QueuePush(Queue*pq, QDataType x);
//队头删除
void QueuePop(Queue* pq);
//初始化
void QueueInit(Queue* pq);
//统计数据个数
int QueueSize(Queue* pq);
//销毁
void Distory(Queue* pq);
//判空
bool QueueEmpty(Queue* pq);

 （1）初始化和销毁

//初始化
void QueueInit(Queue* pq) {
	assert(pq);
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}
//销毁
void Distory(Queue* pq) {
	assert(pq);
	Node* cur = pq->phead;
	while (cur) {
		Node* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

 （2）队尾插入，对头删除

//队尾插入
void QueuePush(Queue* pq, QDataType x) {
	
	Node* tmp = (Node*)malloc(sizeof(Node));
	if (tmp == NULL) {
		perror("malloc");
	}
	tmp->val = x;
	tmp->next = NULL;
	if (pq->phead == NULL) {
		pq->phead = pq->ptail = tmp;
	}
	else {
	
		pq->ptail->next = tmp;
		pq->ptail = tmp;
	}
	pq->size++;
}
//队头删除
void QueuePop(Queue* pq) {
	assert(pq);
	assert(pq->size != 0);
	if (pq->phead->next == NULL) {
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
		pq->size--;
	}
	else {
		Node* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
		if (pq->phead == NULL)
			pq->ptail = NULL;
		pq->size--;
	}
	
}

（3）判空

//判空
bool QueueEmpty(Queue* pq) {
	assert(pq);
	return pq->size == 0;
}

结束！