栈和队列基本操作的实现 (C语言)

注意：

1. 有些地方我们在创建某个结构的时候，可能会使用指针，也可能会使用变量。基本上数组使用变量，链式结构要使用指针，当然数组也可以使用指针，只不过需要在malloc一个结构，而使用变量就不需要malloc也不用释放比较方便。
2. 在定义变量的时候：如果出了函数还要使用就malloc一个空间。而只在函数内部使用直接定义就可以。

栈

栈的概念和结构

概念

只允许在栈顶这一端进行数据的插入和删除，另一端则是栈底。

性质：栈中的数据元素遵循后进先出原则

结构

栈的实现使用数组实现更优（原因：数组实现命中高），也可以用链表（倒过来用）

画图展示

静态栈的结构

因为定长的原因，实际中一般不实用，主要使用的是动态栈。

静态栈结构：

#define N 10
typedef int STDataType;

typedef struct Stack
{
	STDataType a[N];
	int top;
}Stack;

动态栈的结构

typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;         //栈顶
	int capacity;    //容量
}Stack;

栈的实现

我们把函数的声明、实现和测试分别写在三个文件。
分别是：stack.h / stack.c / test.c。这里会着重介绍一下stack.c，stack.c文件存放的是接口实现

函数的声明
Stack.h:

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


#define INITCAPACITY 4
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;        //栈顶元素
	int capacity;   //容量
}Stack;


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

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

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

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

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

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

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

函数的实现
Stack.c:

#include "Stack.h"

void StackInit(Stack* ps)
{
	assert(ps);

	//开辟一个初始化的空间
	ps->a = (STDataType*)malloc(sizeof(STDataType) * INITCAPACITY);
	if (NULL == ps->a)
	{
		perror("Stack::malloc");
		return;
	}

	//结构中的变量置成初始化的值
	ps->capacity = INITCAPACITY;
	ps->top = 0;
}

//判断是否为空，如果为空返回true，不为空返回false
bool StackEmpty(Stack* ps)
{
	assert(ps);
	
	//ps->top为0就代表栈内没有元素
	return ps->top == 0;
}

//销毁栈，因为只在数组ps->a上进行了动态空间开辟，所以释放ps->a就行
void StackDestroy(Stack* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;

	//结构中的变量也都要置为0
	ps->top = 0;
	ps->capacity = 0;
}

//入栈操作
void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	
	//判断是否增容
	if (ps->capacity == ps->top)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capacity * 2);
		if (NULL == tmp)
		{
			perror("StackPush::realloc");
			return;
		}
		//增容成功后，将新开辟的空间地址交给ps->a维护
		ps->a = tmp;
		
		//容量扩充二倍
		ps->capacity *= 2;
	}

	//入栈赋值
	ps->a[ps->top] = x;
	ps->top++;
}


//出栈
void StackPop(Stack* ps)
{
	assert(ps);
	//栈如果为空就不需要再出栈，所以直接断言就可以
	assert(!StackEmpty(ps));

	//出栈，不需要删除，只需要把这块的空间还给操作系统即可
	ps->top--;
}

//取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);
	//栈不能为空
	assert(!StackEmpty(ps));


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

//返回栈的有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);

	//直接返回下标即可，下标指向后一个为使用的空间位置，可以代表元素个数
	return ps->top;
}

测试
test.c:

#include "Stack.h"


void TestStack()
{
	Stack s;
	
	//栈初始化
	StackInit(&s);

	//入栈
	StackPush(&s, 1);
	StackPush(&s, 2);
	StackPush(&s, 3);

	//打印栈顶元素+出栈
	printf("%d ", StackTop(&s));
	StackPop(&s);

	//入栈
	StackPush(&s, 4);
	StackPush(&s, 5);

	//判断是否为空，不为空执行循环
	while (!StackEmpty(&s))
	{
		//打印栈顶元素+出栈
		printf("%d ", StackTop(&s));
		StackPop(&s);
	}
	printf("\n");

	//销毁栈
	StackDestroy(&s);

}

队列

队列的概念和结构

概念

在一端进行插入操作，在另一端进行删除数据的操作的特殊线性表。
性质：先进先出

结构

队列也可以数组或者链表实现，但是使用链表更优，数组效率在这里使用更低。

画图展示

结构

这里在定义的时候需要定义一个尾指针，方便进行插入操作。因为当有多个参数的时候，再都放在结构体里比较方便调用。
可以把上面一个结构体当作局部，把下面结构体当作整体。如图所示

//链式结构：表示队列
typedef int QDataType;
typedef struct QNode
{
	struct QNode* next;
	QDataType data;
}QNode;


//队列的结构
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	
	//方便下面实现有效数据的大小而定义
	size_t size;
}Queue;

队列的实现

我们把函数的声明、实现和测试分别写在三个文件。
分别是：Queue.h / Queue.c / test.c。这里会着重介绍一下Queue.c，Queue.c文件存放的是接口实现。

函数的声明
Queue.h:

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


//链式结构：表示队列
typedef int QDataType;
typedef struct QNode
{
	struct QNode* next;
	QDataType data;
}QNode;


//队列的结构
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	size_t size;
}Queue;


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

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

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

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

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

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

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

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

函数的实现
Queue.c:

#include "Queue.h"

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

	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

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

	QNode* cur = pq->head;
	while (cur)
	{
		//保存当前地址的下一个地址，以防释放当前地址后找不到下一个地址
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->head = NULL;
	pq->size = 0;
	pq->tail = NULL;
}

//检测队列是否为空,为空返回true，否则返回false
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	//当头节点和尾节点都为空，则队列为空
	return pq->head == NULL && pq->tail == NULL;

	//or有效元素为0的时候也是为空的时候
	//return pq->size == 0;
}



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

	//开辟新的节点
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (NULL == newnode)
	{
		perror("Push::malloc");
		return;
	}

	//存放x
	newnode->data = x;
	//尾插，尾部的next置空
	newnode->next = NULL;


	//解决首节点为空的情况
	if (pq->head == NULL)
	{
		//这里也可以断言一下
		assert(pq->tail == NULL);

		pq->head = pq->tail = newnode;
	}
	else
	{
		//正常链接，更新尾部指针
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;

}

//队头出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	QNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;

	//判断出队列的是不是最后一个元素，如果是还要把尾节点置空
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}
	
	pq->size--;
}

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

	return pq->head->data;
}

//获取队列尾部元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

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

	return pq->size;
}

测试
test.c:

void TestQueue()
{
	Queue q;
	QueueInit(&q);

	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);

	printf("QueueBack = %d\n", QueueBack(&q));

	printf("size = %d\n", QueueSize(&q));


	while (!(QueueEmpty(&q)))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n");



	QueueDestroy(&q);
}


int main()
{
	TestQueue();
	return 0;
}

总结

栈和队列是一种特殊的线性结构。
性质：栈的数据元素遵循先进后出的原则。队列则遵循先进先出的原则。

栈和队列的结构比较简单，这里就不再详细介绍，相信理解前面的链表等结构，对这里也不会有太多疑问。

注意：数据结构的栈和操作系统的栈区，可以理解成两个学科的相同名词。