数据结构-栈和队列（Stack&&Queue)

一.栈和队列的本质

 栈和队列的本质：一种操作受限制的线性表。

二.栈的概念

2.1 栈的定义：

 栈：是只允许在一段进行插入删除的线性表。我们把运行插入删除的一端叫做栈顶，把不能操作和删除的一端叫做栈底。栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构。

   基本结构：

栈顶：栈中允许进行插入删除的那一端。
栈底：固定的，不允许进行插入和删除的另一端。
空栈：不含任何元素的空栈。

 2.2 栈的基本操作

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

栈结构的定义为：

// 支持动态增长的栈
typedef int STDataType;

typedef struct Stack
{
	STDataType* _a;
	size_t _top;		// 栈顶
	size_t _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);

 若现在有一个栈，_capacity是5，则栈的普通情况、空栈、满栈的情况分别如下图所示：

 

 

 三.用顺序表实现栈

基本函数定义 Stack.h文件

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

typedef struct Stack
{
	STDataType* _a;
	size_t _top;		// 栈顶
	size_t _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);

 函数实现：Stack.c文件

#include"Stack.h"

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

void StackPush(Stack* ps, STDataType data)
{
	if (ps->_capacity == ps->_top)
	{
		size_t newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		STDataType*tmp = (STDataType*)realloc(ps->_a,sizeof(STDataType) * newcapacity);
		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(!StackEmpty(ps));

	ps->_top--;

}
STDataType StackTop(Stack* ps)
{
	assert(ps);
	//为空则没有栈顶元素

	assert(!StackEmpty(ps));

	int x = ps->_a[ps->_top - 1];
	return x;
}
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->_top;
}

int StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->_top == 0;
}

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

	free(ps->_a);

	ps->_capacity = ps->_top = 0;
}

四.队列

4.1 队列的概念

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。

队头：允许删除的一端，又称队首。
队尾：允许插入的一端。
空队列：不包含任何元素的空表。

  4.2 队列的基本操作

因为顺序表的插入会大量移动元素，所以链表实现队列更优。队列的顺序实现是指分配一块连续的存储单元存放队列中的元素，并附设两个指针：队头指针 front指向队头元素，队尾指针 rear 指向队尾元素的下一个位置。

 队列：Queue.h文件

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

typedef int QDataType;
// 链式结构：表示队列 
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
	size_t _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);

Queue.c 文件

#include"Queue.h"

void QueueInit(Queue* pq)
{
	assert(pq);

	pq->_front= NULL;
	pq->_rear = NULL;
	pq->_size= 0;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->_front;
	while (cur)
	{
		QNode* next = cur->_next;
		free(cur);
		cur = next;
	}

	pq->_front= 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\n");
		return;
	}
	newnode->_data = x;
	newnode->_next = NULL;

	if (pq->_rear == NULL)
	{
		assert(pq->_front== 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));

	// 1、一个节点
	// 2、多个节点
	if (pq->_front->_next == NULL)
	{
		free(pq->_front);
		pq->_front= pq->_rear = NULL;
	}
	else
	{
		// 头删
		QNode* next = pq->_front->_next;
		free(pq->_front);
		pq->_front= next;
	}

	pq->_size--;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->_front->_data;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->_rear->_data;
}

int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->_size;
}

int  QueueEmpty(Queue* pq)
{
	assert(pq);

	/*return pq->_front== NULL
		&& pq->_rear == NULL;*/
	return pq->_size;
}