数据结构——栈和队列（C语言）

一、栈

1.栈的概念

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

上图所示，栈的实现使用的是顺序表，入栈出栈即顺序表的尾插和尾删，不需要挪动元素，时间复杂度为O(1);如果使用链表实现栈，那么出栈需要不断地查找栈顶元素的前一个节点，时间复杂度为O(n)。

2.栈的实现

（1）栈的定义

typedef int STDataType;
typedef struct StackList
{
	STDataType* stack;//指向数组的指针，实现动态开辟内存
	size_t top;//指向栈顶元素（初始化top为-1，则指向栈顶元素；top为0，则指向栈顶元素的下一个位置）
	size_t capacity;//（标明当前栈的最大容量）
}ST;

（2）栈的初始化

void StackInit(ST* ps)
{
	assert(ps);
	ps->stack = NULL;
	ps->top = ps->capacity = 0;
}

（3）入栈

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
	if (ps->capacity == ps->top)
	{
		ps->stack = (STDataType*)realloc(ps->stack,sizeof(STDataType)*newcapacity);
		//（realloc动态开辟内存）
		if (ps->stack==NULL)//开辟内存失败，程序终止
		{
			exit(-1);
		}
		ps->capacity = newcapacity;
	}
	ps->stack[ps->top] = x;//将x插入top指向的位置
	ps->top++;
}

（4）出栈

//出栈 top指针前移即可 再入栈的元素会覆盖原来位置的数据
void StackPop(ST* ps)
{
	assert(ps);
	if (ps->top != 0)
		ps->top--;
}

（5）判空、返回栈当前的有效元素个数以及返回栈顶元素

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
STDataType StackTop(ST* ps)
{
	assert(ps);
	return ps->stack[ps->top - 1];
}

（6）销毁

void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->stack);
	ps->stack = NULL;
	ps->top = ps->capacity = 0;
}

二、队列

1.队列的概念

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

入队操作看做线性表的尾插，出队操作相当于线性表的头删。
使用链表实现队列，出队入队的时间复杂度均为O(1)。

2.队列的实现

（1）队列的定义

typedef int QDataType;

typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QNode;

//指向队列头和尾的结构
typedef struct Queue
{
	QNode* head;//指向队头
	QNode* tail;//指向队尾
}Queue;

（2）初始化

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}

（3）入队——单链表的尾插

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	//队列为空，head和tail都指向newnode
	if (pq->tail == NULL)
	{
		pq->head = pq->tail= newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

（4）出队——单链表的头删

void QueuePop(Queue* pq)
{
	assert(pq);
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;//记录队头的下一个节点
		free(pq->head);
		pq->head = next;
	}
}

（5）其余操作

//判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}
//返回队列的长度
size_t QueueSize(Queue* pq)
{
	assert(pq);
	assert(pq->head && pq->tail);
	QNode* next = pq->head;
	size_t size=0;
	while (next)
	{
		size++;
		next = next->next;
	}
	return size;
}
//返回队头元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);

	return pq->head->data;
}
//返回队尾元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->tail);

	return pq->tail->data;
}