数据结构———栈和队列（实现源码）

1.栈

1.1栈的概念及结构

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

栈必须遵循，后进先出LIFO（Last In First Out）的原则。
只能栈顶插入，栈顶弹出

1.2栈的实现

栈可以用数组实现，也可用链表实现
链表：创建新元素，用新元素的next指向之前的元素，出栈删除元素指针指向下一个元素，free掉第一个元素就可以，我们一般不用链表实现栈

数组实现：

我们只要注意栈顶插入与删除就可以了，栈的实现相对链表的实现是比较简单的
头文件Stack.h

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

typedef int STDatatype;

typedef struct Stack
{
	STDatatype* a;
	int top;
	int capacity;
}Stack;

//初始化
void STInit(Stack* ps);
// 销毁
void STDestroy(Stack* ps);
//删除
void STPop(Stack* ps);
//插入
void STPush(Stack* ps,STDatatype x);
//计算个数
int STSize(Stack* ps);
//判断是否为空
bool STEmpty(Stack* ps);
//出栈
STDatatype STTop(Stack* ps);

Stack.c

#define _CRT_SECURE_NO_WARNINGS
#include "Stack.h"


//初始化
void STInit(Stack* ps)
{
	assert(ps);
	ps->a = (STDatatype*)malloc(sizeof(STDatatype) * 4);
	if (ps->a == NULL)
	{
		printf("malloc fail");
		return;
	}
	ps->capacity = 4;
	ps->top = 0;
}

// 销毁
void STDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

//插入
void STPush(Stack* ps, STDatatype x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		STDatatype* tmp = (STDatatype*)realloc(ps->a,sizeof(STDatatype) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("malloc fail");
			return;
		}
		ps->a = tmp;
		ps->capacity *= 2;

	}
	ps->a[ps->top] = x;
	ps->top++;
}


//判断是否为空
bool STEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;
}

//删除
void STPop(Stack* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	ps->top--;
}


//计算个数
int STSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

//出栈
STDatatype STTop(Stack* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	return ps->a[ps->top - 1];
}

test.c
这里是测试用例，用来检测代码是否有bug

#define _CRT_SECURE_NO_WARNINGS
#include "Stack.h"

void test1()
{
	Stack st ;
	STInit(&st);
	STPush(&st, 1);

	printf("%d ", STTop(&st));
	STPop(&st);

	STPush(&st, 2);
	STPush(&st, 3);

	printf("%d ", STTop(&st));
	STPop(&st);

	STPush(&st, 4);

	STPush(&st, 5);

	printf("%d\n", STSize(&st));

	while (!STEmpty(&st))
	{
		printf("%d ", STTop(&st));
		STPop(&st);
	}
	STDestroy(&st);
}



int main()
{
	test1();
	return 0;
}

2.队列

2.1队列的概念及结构

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

2.2队列的实现

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

如果使用链表实现，那我们就得写两个指针，一个指向队头用来出队，一个指向队尾用来入队
Queue.h

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

typedef int QDatatype;

typedef struct QueueNode
{
	struct QueueNode* next;
	QDatatype a;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int sz;
}Queue;

//初始化
void QueueInit(Queue* qp);
//销毁
void Queuedestroy(Queue* qp);
//插入
void QueuePush(Queue* qp, QDatatype x);
//删除
void QueuePop(Queue* qp);
//判空
bool QueueEmpty(Queue* qp);
//计算个数
int QueueSize(Queue* qp);
//第一个元素
QDatatype QueueFront(Queue* qp);
//最后一个元素
QDatatype QueueBack(Queue* qp);

Queue.c

#define _CRT_SECURE_NO_WARNINGS
#include "Queue.h"


//初始化
void QueueInit(Queue* qp)
{
	assert(qp);
	qp->head = qp->tail = NULL;
	qp->sz = 0;
}

//销毁
void Queuedestroy(Queue* qp)
{
	assert(qp);
	QNode* cur = qp->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	qp->head = qp->tail = NULL;
	qp->sz = 0;
}

//插入
void QueuePush(Queue* qp, QDatatype x)
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->next = NULL;
	newnode->a = x;
	if (qp->head == NULL)
	{
		assert(qp->tail == NULL);
		qp->head = qp->tail = newnode;
	}
	else
	{
		qp->tail->next = newnode;
		qp->tail = newnode;
	}
	qp->sz++;
}

//删除
void QueuePop(Queue* qp)
{
	assert(qp);
	assert(qp->head);

	/*
	QNode* next = qp->head->next;
	free(qp->head);
	qp->head = next;
	qp->sz--;

	if (qp->head == NULL)
		qp->head = qp->tail = NULL;
	*/

	if (qp->head->next == NULL)
	{
		free(qp->head);
		qp->tail = qp->head = NULL;
	}
	else
	{
		QNode* next = qp->head->next;
		free(qp->head);
		qp->head = next;
	}
	qp->sz--;

}

//判空
bool QueueEmpty(Queue* qp)
{
	assert(qp);
	return qp->sz == 0;
}

//计算个数
int QueueSize(Queue* qp)
{
	assert(qp);

	return qp->sz;
}

//第一个元素
QDatatype QueueFront(Queue* qp)
{
	assert(qp);
	assert(!QueueEmpty(qp));
	return qp->head->a;
}

//最后一个元素
QDatatype QueueBack(Queue* qp)
{
	assert(qp);
	assert(!QueueEmpty(qp));
	return qp->tail->a;
}

test.c
这里是测试用例，用来检测代码是否有bug

#define _CRT_SECURE_NO_WARNINGS
#include "Queue.h"

void test1()
{
	Queue q1;
	QueueInit(&q1);
	QueuePush(&q1, 1);
	QueuePush(&q1, 2);
	QueuePush(&q1, 3);
	QueuePush(&q1, 4);
	QueuePush(&q1, 5);
	printf("%d ", QueueBack(&q1));

	while (!QueueEmpty(&q1))
	{
		printf("%d ", QueueFront(&q1));
		QueuePop(&q1);
	}
	printf("%d ", QueueSize(&q1));
}

int main()
{
	test1();

	return 0;
}

3.栈和队列的练习题

设计循环队列题目
设计循环队列讲解