简单的栈与队列

栈的概念及结构

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

  栈结构示意图（1）；
  （1）的"栈顶指针top"指向当前栈的栈顶元素处，栈的这种表现形式，top的起始数值等于-1，当栈中存在一个元素时top=0,所以在判断空栈时把top是否等于-1作为判空条件（top==-1为空栈）。

  栈结构示意图（2）；
  （2）本质上与（1）相同，区别在于（2）的"栈顶指针top"指向当前栈的栈顶元素的下一个，top起始值为0；把top是否等于0作为判断栈空的条件（top==0栈空）。

栈的实现

😉😉😉 本文栈以第二种形式实现，即top指向栈顶元素的下一个 （使用顺序表数据结构进行实现（原因：顺序表尾插尾删快捷高效正适用于栈的结构））
💃读者可先阅读以下头文件，对栈的基本功能先做一个大致了解。

//栈的基本功能

#pragma once
#include<stdio.h>
#include<stdlib.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);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);

// 初始化栈

typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;

// 入栈

void StackPush(Stack* ps, STDataType data) 
{
	assert(ps);
	int newcapacity = (ps->_capacity == 0 ? 4 : ps->_capacity * 2);
	if (ps->_capacity == ps->_top) 
	{
		STDataType* tmp = (STDataType*)realloc(ps->_a, (sizeof(STDataType) * newcapacity));
		if (tmp == NULL) 
		{
			perror("realloc");
			exit(-1);
		}
		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;
}

💚注意对栈空间进行断言，不能对一个空栈进行出栈呀💚

// 获取栈顶元素

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;//top即为有效元素个数
}

// 检测栈是否为空

int StackEmpty(Stack* ps) 
{
	assert(ps);
	//if (ps->_top == 0) 
	//{
	//	return 1;
	//}
	//else 
	//{
	//	return 0;
	//}
  return ps->_top == 0;
}

// 销毁栈

void StackDestroy(Stack* ps) 
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}

队列的概念及结构

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

😉队列结构示意图😉

队列的实现

  由于队列先进先出的特性，应使用链表对队列进行实现
💃读者可先阅读以下头文件，对栈的基本功能先做一个大致了解。

队列的基本功能

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int QDataType;
// 链式结构：表示队列 
typedef struct QListNode
{
	struct QListNode* next;
	QDataType data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* front;//指向头节点
	QNode* rear;//指向尾节点
	int size;//节点个数（用size大小对队列直接进行判空）
}Queue;

// 初始化队列 
void QueueInit(Queue* q);
// 队尾入队列 
void QueuePush(Queue* q, QDataType data);
// 队头出队列 
void QueuePop(Queue* q);
// 获取队列头部元素 
QDataType QueueFront(Queue* q);
// 获取队列队尾元素 
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数 
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);

//获得一个节点

QNode* BuyNode(QDataType _data) 
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL) 
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = _data;
	newnode->next = NULL;
	return newnode;
}

// 初始化队列

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

// 队尾入队列

void QueuePush(Queue* q, QDataType data) 
{
	assert(q);
	QNode* newnode=BuyNode(data);
	if (q->front == NULL) 
	{
		q->front = q->rear = newnode;
	}
	else 
	{
		q->rear->next = newnode;
		q->rear = newnode;
	}
	++q->size;
}

💚入队列用的尾插💚

// 队头出队列

void QueuePop(Queue* q) 
{
	assert(q);
	assert(q->front != NULL);
	QNode* delete = q->front;
	q->front = q->front->next;
	free(delete);
}

💚出队列用的头删💚

// 获取队列头部元素

QDataType QueueFront(Queue* q) 
{
	assert(q);
	assert(q->front != NULL);
	return q->front->data;
}

// 获取队列队尾元素

QDataType QueueBack(Queue* q) 
{
	assert(q);
	assert(q->front != NULL);
	return q->rear->data;
}

// 获取队列中有效元素个数

int QueueSize(Queue* q) 
{
	assert(q);
	return q->size;
}

// 检测队列是否为空

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q) 
{
//（1）
	//if (q->front == NULL) 
	//{
	//	return 1;
	//}
	//else 
	//{
	//	return 0;
	//}
	//（2）
	//return q->front == NULL;
	//(3)
	return q->size==0;
}

// 销毁队列

void QueueDestroy(Queue* q) 
{
	assert(q);
	while (q->front!=NULL) 
	{
		QNode* delete = q->front;
		q->front = q->front->next;
		free(delete);
	}
	q->front = NULL;
	q->rear = NULL;
	q->size = 0;
}

💃💃本章到此结束，希望对大家有所帮助💃💃
没有任何一种付出是白费的，只要坚持，就一定会有收获。