数据结构-栈和队列

在数据结构中，栈和队列是两种很重要的数据结构，那么栈和队列到底是一种以什么样的方式去存储数据的，以及添加和删除是以什么样的规律去运行的，接下俩由我给大家详细讲解一下。

栈

1. 我们先来了解一下栈的基本概念和存储结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作**。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。**栈中的元素遵循后进先出的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，如数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶

2. 栈的实现

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

用结构体定义一个栈，capacity是数组的大小，top是指向数组的尾，也就是栈顶，方便我们压栈和入栈。

typedef int STDataType;
typedef struct Stack {
	STDataType* a;
	int capacity;
	int top;
}ST;

初始化栈

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

	/*ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;*/
	//默认给栈内开辟四个元素的空间
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL) {
		perror("malloc fail");
		exit(-1);
	}
	ps->top = 0;
	ps->capacity = 4;
}

栈的销毁

void StackDestory(ST* ps) {
	assert(ps);//断言结构体指针不为空
	//释放栈空间，并且把元素个数和容量都置为0
	free(ps->a);
	ps->capacity = 0;
	ps->top = 0;
}

压栈

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//如果栈顶到了容量的最大值，那么就要扩容，否则就会存在内存泄漏和指针越界的问题
	if (ps->capacity == ps->top) {
		STDataType* tem = realloc(ps->a,sizeof(STDataType) * ps->capacity * 2);
		if (tem == NULL) {
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tem;
		ps->capacity *= 2;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

出栈

void StackPop(ST* ps) {
	assert(ps);
	assert(ps->top > 0);//如果top等于0或者小于0那么栈为空，就不能再出栈了
	ps->top--;
}

队列

1. 队列的概念和存储结构

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

2. 队列的实现
   队列用也可以数组和链表的结构实现，使用链表的结构实现更优，因为如果使用数组的结构，从数组头上出数据，效率会比较低。使用链表头删比较方便。

队列的定义

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

//队列的结构
typedef struct Queue
{	
	//定义一个队列头指针和尾指针方便尾插和头删
	QNode* front;
	QNode* rear;
	int size;
}Queue;

初始化队列，头指针和尾指针都置为空

void QueueInit(Queue* pq) {
	assert(pq);
	pq->front = NULL;
	pq->rear = NULL;
	pq->size = 0;
}

队列的插入

void QueuePush(Queue* pq, QDataType x) {
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL) {
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	//如果尾指针为空，证明队列为空，
	if (pq->rear == NULL) {
		pq->front = pq->rear = newnode;
	}
	else {
	//如果尾指针不为空那么就尾插数据
		pq->rear->next=newnode;
		pq->rear = newnode;
	}
	//元素个数++
	pq->size++;
}

队列的删除

void QueuePop(Queue* pq) {
	assert(pq);
	assert(!QueueEmpty(pq));
	if (pq->front->next == NULL) {
		//如果只剩一个元素那么直接释放内存，然后指针置空
		free(pq->front);
		pq->front = pq->rear = NULL;
	}
	else
	{
		QNode* prve = pq->front;
		pq->front = pq->front->next;
		free(prve);
		
	}
	pq->size--;
	
}

队列的销毁

void QueueDestroy(Queue* pq) {
	assert(pq);
	QNode* cur = pq->front;
	while (cur) {
		//如果头指针不为空，那么就释放每一个元素开辟的空间
		QNode* del = cur;
		cur = cur->next;
		free(del);
	}
	pq->front = pq->rear = NULL;
	pq->size = 0;
	
}

关于栈和队列这两种存储结构都是非常的简单的，我就分享到这里，如果想要完整的源代码点击 链接