数据结构之栈和队列

栈和队列是数据结构的线性表中依附顺序表和链表产生的两种对前面两者进行规则限定的特殊数据结构。本质还是顺序表和链表，只不过是加以改装。

目录

 一.栈的概念

栈的模拟实现

 二.队列的概念

队列的模拟实现

---

 一.栈的概念

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。

进行数据插入和删除操作的一端 称为栈顶，另一端称为栈底。 栈中的数据元素遵守后进先出 LIFO （ Last In First Out ）的原则。

压栈：栈的插入操作叫做进栈 / 压栈 / 入栈， 入数据在栈顶 。

出栈：栈的删除操作叫做出栈。 出数据也在栈顶 。

 

栈的模拟实现

要实现栈，首先要想清楚是用节点式（链表式结构）还是连续空间式 （顺序表）来管理、实现栈。而要想弄清楚选择种结构就要知道栈的功能需求。

根据栈的概念就知道栈的功能需求就是入栈，出栈。对应尾插，尾删。我们知道，顺序表在这方面是优于链表的。因为链表在尾插、尾删的时候要找到尾节点以及尾节点的前一个，代价较大。顺序表就可以直接进行尾插、尾删。

stack.h 

 stack.c

void IntiStack(Stack* stack)//初始化栈
{
	DateType* tmp = (DateType*)malloc(4*sizeof(DateType));
	assert(tmp);
	stack->arr = tmp;
	stack->top = 0;//top置为0
	stack->capcity = 4;//初始容量为4
}
void PushStack(Stack* stack, DateType n)//入栈，尾插
{
	assert(stack);
	if (stack->top == stack->capcity)//检查栈是否满了，满了就需要扩容
	{
		//扩容
		DateType* tmp = realloc(stack->arr,2 * stack->capcity * sizeof(DateType));
		assert(tmp);
		stack->arr = tmp;
		stack->capcity *= 2;//容量变为2倍
	}
	stack->arr[stack->top] = n;//top位置存放数据
	stack->top++;//top向后迭代
}
void PopStack(Stack* stack)//出栈，尾删
{
	assert(stack);
	assert(!StackEmpty(stack));//保证栈不为空，空栈不能删除
	stack->top--;
}
bool StackEmpty(Stack* stack)
{
	assert(stack);
	return stack->top == 0;//如果top为0，代表栈为空，返回true
}
int StackSize(Stack* stack)
{
	assert(stack);
	return stack->top;//直接返回有效数据个数top
}
DateType TopStack(Stack* stack)
{
	assert(stack);
	assert(!StackEmpty(stack));//保证栈不为空，栈为空stack->top-1==-1就会越界
	return stack->arr[stack->top - 1];
}
void DestoryStack(Stack* stack)
{
	assert(stack);
	free(stack->arr);//释放顺序表空间
	stack->arr = NULL;
	stack->capcity = 0;
	stack->top = 0;
}

 二.队列的概念

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

入队列：进行插入操作的一端称为 队尾      出队列：进行删除操作的一端称为 队头

 

 入队列是进行尾插，出队列是进行头删。如果还用顺序表式结构头删的时候代价太大，所以这里用节点式结构来实现队列。

队列的模拟实现

 queue.h

 queue.h中包含队列的基本功能：入列、出列、获取队首数据、获取队尾数据、获取队列中有效数据个数。

queue.c 

void IntiQueue(Queue* queue)//初始化队列
{
	assert(queue);
	queue->phead = NULL;
	queue->ptail = NULL;
	queue->size = 0;
}
void PushQueue(Queue* queue, DateType n)//入列，尾插
{
	assert(queue);
	Node* newnode = (Node*)malloc(sizeof(Node));//创建新节点
	assert(newnode);
	newnode->date = n;
	newnode->next = NULL;

	if (queue->ptail == NULL)//队列为空，相当于头插
	{
		assert(queue->phead==NULL);
		
		queue->phead = newnode;//头插
		queue->ptail = newnode;//迭代ptail，利于下次尾插入列
	}
	else//队列不为空，正常尾插
	{
		queue->ptail->next = newnode;//尾插
		queue->ptail = newnode;//迭代ptail
	}
	queue->size++;//有效数据加一
}
void PopQueue(Queue* queue)//头删出列
{
	assert(queue);
	assert(!QueueEmpty(queue));//保证队列不为空
	
	if (queue->phead->next == NULL)//一个节点，直接删
	{
		queue->phead = NULL;
		queue->ptail = NULL;
	}
	else//多个节点
	{
		Node* next = queue->phead->next;//先保存头节点的下一个节点地址
		free(queue->phead);//释放头节点空间
		queue->phead = next;//将头节点设为next
	}
	queue->size--;//有效数据减一
}
bool QueueEmpty(Queue* queue)//判断队列是否为空
{
	assert(queue);
	return queue->size == 0;//有效数据为0，队列为空，返回true
}
DateType QueueFront(Queue* queue)//获取队列头元素
{
	assert(queue);
	assert(!QueueEmpty(queue));//队列非空

	return queue->phead->date;//直接返回
}
DateType QueueBank(Queue* queue)//获取队列尾元素
{
	assert(queue);
	assert(!QueueEmpty(queue));//队列非空
	
	return queue->ptail->date;//直接返回
}
int QueueSize(Queue* queue)//获取有效数据个数
{
	assert(queue);
	return queue->size;//直接返回
}
void DestoryQueue(Queue* queue)//销毁队列
{
	assert(queue);
	Node* cur = queue->phead;
	while (cur)//循环销毁每一个节点
	{
		Node* next = cur->next;
		free(cur);
		cur = next;
	}
	queue->phead = NULL;//置空，防止野指针
	queue->ptail = NULL;//置空，防止野指针
	queue->size = 0;
}

总结：栈和队列只不过是顺序表与链表的子结构，关键在于实际问题中选取合适的数据结构，以及可以灵活应用数据结构解决问题。