线性表之栈和队列

前言

这次介绍的数据结构也是属于线性表，之前介绍过顺序表与链表感兴趣的铁铁可以看我收录在数据结构下的关于顺序表与链表的博客。

栈

1.栈的概念已经结构

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

• **结构：**栈的基本结构可以如图所示

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
**出栈：**栈的删除操作叫做出栈。出数据也在栈顶。

栈顶（Top）：线性表允许进行插入删除的那一端。
栈底（Bottom）：固定的，不允许进行插入和删除的另一端。
空栈：不含任何元素的空表。

2.栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的
代价比较小。
本次就像大家介绍用数组实现栈

• 定义栈

typedef struct Stack
{
	STData* STdata;
	int top;//记录栈顶
	int capacity;//栈的容量

}Stack;

这里采用的是动态数组实现栈这样更灵活实用

• 压栈和出栈

首先是压栈，只需把具体的数据进行数组尾插即可，记得检查栈的空间，如果空间不够扩容就行。

void PushStack(Stack* ps,int x)
{
	assert(ps);
	int newcapacity = 0;
	if (ps->capacity == 0)
	{
		newcapacity = 4;
	}
	else
	{
		newcapacity = ps->capacity == ps->top ? 2 * ps->capacity : ps->capacity;

	}
	STData*ptr= (STData*)realloc(ps->STdata, sizeof(STData) * newcapacity);
	if (ptr == NULL)
	{
		perror("realloc");
		return;
	}
	else {
		ps->STdata = ptr;
		ps->capacity = newcapacity;
		ps->STdata[ps->top] = x;
		ps->top++;
	}
}

出栈也只需尾删数据即可代码如下

void PopStack(Stack* ps)
{
	assert(ps);
	if (ps->top == 0)
	{
		perror("PopStack");
		return;
	}
	ps->top--;

}

• 栈的其他基本操作

获取栈顶元素

STData Stacktop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->STdata[ps->top-1];
}

栈的判空

int Stackempty(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);
	if (ps->top == 0)
		return 0;
	else
		return 1;
}

栈的销毁

void StackDestroy(Stack* ps)
{
	free(ps->STdata);
	free(ps);
	ps = NULL;
	ps->STdata = NULL;
}

栈的大小

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

队列

1.队列的概念及结构

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

基本结构如图

2.队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数
组头上出数据，效率会比较低。

• 队列的定义

我用一个结构体来表示队列的结点，再定定义一个结构体表示这个队列包含队头队尾已经队列大小。

typedef int Quedata;
typedef struct QNode
{
	struct QNode* next;
	Quedata data;

}QNode;
typedef struct Queue
{
	QNode* front;
	QNode* rear;
	int size;
}Queue;

• 出队列与入队列

类似于单链表的头删尾插，这里不过多介绍直接上代码

void Queuepush(Queue* q, int x)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	if (q->rear == NULL)
	{
		q->front = q->rear = newnode;
		newnode->next = NULL;
	}
	else
	{
		q->rear->next = newnode;
		newnode->next = NULL;
	}
	q->size++;

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

• 队列的其他操作

获得对头或者队尾元素，队列的判空，销毁，大小等

Quedata QueueFront(Queue* q)
{
	assert(q);
	assert(q->front);
	return q->front->data;
}
Quedata QueueBack(Queue* q)
{
	assert(q);
	assert(q->rear);
	return q->rear->data;
}
int QueueSize(Queue* q)
{
	return q->size;
}
int QueueEmpty(Queue* q)
{
	return q->size;
}
void QueueDestroy(Queue* q)
{
	QNode* cur = q->front;
	while (cur)
	{
		QNode* temp = cur;
		cur = cur->next;
		free(temp);
		temp = NULL;
	}
	q->front = q->rear = NULL;
	q->size = 0;
}

总结

这次主要介绍了线性表的另外两种结构栈和队列，以及分别用数组和链表来实现栈和队列。

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

# 总结

这次主要介绍了线性表的另外两种结构栈和队列，以及分别用数组和链表来实现栈和队列。