C语言实现栈和队列

栈

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

称为栈顶，另一端称为栈底。 栈中的数据元素遵守后进先出 LIFO （ Last In First Out ）的原则。

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

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

总而言之，栈的结构决定了数据一定是后进先出！！！

栈的实现

由于栈的特殊性，我们可以使用数组来实现更好，只需要在数组后面添加数据即可

代码实现

首先，先将基本的栈实现函数列举出来，并定义一个可动态增长的数组来模拟存放栈（后续需要使用到向系统申请空间的知识）

#include<stdio.h>
#include<assert.h>
#include<stdbool.h>
#include<stdlib.h>
#define N = 10;
typedef int STDateType;
//动态增长的数组（栈）
typedef struct Stack {
    STDateType* a;
    int top;
    int capacity;
}ST;
//初始化栈
void StackInit(ST* ps);
//销毁栈
void StackDestory(ST* ps);
//入栈
void StackPush(ST* ps, STDateType x);
//出栈
void StackPop(ST* Ps);
//获取栈顶元素
STDateType StackTop(ST* ps);
//检查栈是否为空，如果为空返回非0结果，不为空返回0；
bool StackEmpty(ST* ps);
//获取栈中有效元素个数
int StackSize(ST* ps);

而各个函数的具体代码由下图列出（需要注意的是，每个函数都需要使用到assert函数，为了防止数组地址出错且更好的查看错误）

#include<stdio.h>
#include<assert.h>
#include<stdbool.h>
#include<stdlib.h>
#define N = 10;
typedef int STDateType;
//动态增长的数组（栈）
typedef struct Stack {
    STDateType* a;
    int top;
    int capacity;
}ST;
//初始化栈
void StackInit(ST* ps);
//销毁栈
void StackDestory(ST* ps);
//入栈
void StackPush(ST* ps, STDateType x);
//出栈
void StackPop(ST* Ps);
//获取栈顶元素
STDateType StackTop(ST* ps);
//检查栈是否为空，如果为空返回非0结果，不为空返回0；
bool StackEmpty(ST* ps);
//获取栈中有效元素个数
int StackSize(ST* ps);

void teststack() {
    ST st;
    StackInit(&st);
    StackPush(&st, 1);
    StackPush(&st, 2);
    StackPush(&st, 3);
    StackPush(&st, 4);
    StackPush(&st, 5);
    StackPush(&st, 6);

    while (!StackEmpty(&st)) {
        printf("%d ", StackTop(&st));
        StackPop(&st);
    }
    
    StackDestory(&st);
}

int main() {

    teststack();


    return 0;
}



//初始化栈
void StackInit(ST* ps)
{
    assert(ps);
    ps->a = NULL;
    ps->top = 0;
    ps->capacity = 0;
}

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

//入栈
void StackPush(ST* ps, STDateType x)
{
    assert(ps);
    if (ps->top == ps->capacity)
    {
        int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
        STDateType* tmp = (STDateType*)realloc(ps->a, sizeof(STDateType) * newCapacity);
        if (tmp == NULL)
        {
            printf("realloc fail\n");
            exit(-1);
        }
        ps->a = tmp;
        ps->capacity = newCapacity;
    }
    ps->a[ps->top] = x;
    ps->top++;
}

//出栈
void StackPop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));
    ps->top--;
}
//获取栈顶元素

STDateType StackTop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));
    return ps->a[ps->top - 1];
}

//检查栈是否为空，如果为空返回非0结果，不为空返回0；
bool StackEmpty(ST* ps)
{
    assert(ps);
    return ps->top == 0;
}

//获取栈中有效元素个数
int StackSize(ST* ps)
{
    assert(ps);
    return ps->top;
}

在main函数的teststack函数中，我们插入了123456六个元素，然后循环打印，每打印一次然后再将栈顶的元素取出，最后打印完成再回收空间，代码运行结果如下

队列

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

FIFO(First In First Out) 入队列：进行插入操作的一端称为 队尾 出队列：进行删除操作的一端称为 队头

总而言之，队列就是一个先进先出的数据，就好比排队吃饭，第一个进去排队的，肯定是第一个先吃饭的！

就好比右图的排队吃饭一样！！！

队列的实现

由于队列的特殊性，使用数组会比较麻烦，因为数组一般是从尾部插入尾部取出，所以我们此次使用链表来实现

代码实现

首先，将队列实现的函数声明一下

#include<stdio.h>
#include<assert.h>
#include<stdbool.h>
#include<stdlib.h>
#define N = 10;
typedef int QDateType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDateType data;
}QNode;
//为了更好的使用指针，我们定义一个结构体来存储两个指针
typedef struct Queue
{
	QNode* head;
	QNode* tail;
}Queue;
//初始化队列
void QueueInit(Queue* pq);
//销毁队列
void QueueDestroy(Queue* pq);
//队尾入队列
void QueuePush(Queue* pq, QDateType x);
//队头出队列
void QueuePop(Queue* pq);
//获取队列头部元素
QDateType QueueFront(Queue* pq);
//获取队列尾部元素
QDateType QueueBack(Queue* pq);
//检测队列是否为空，为空返回非0，非空返回0
bool QueueEmpty(Queue* pq);
//获取队列有效元素个数
int QueueSize(Queue* pq);

其次是函数的实现

在main函数中的test函数中，我们插入了123456六个元素，然后循环打印，每打印一次然后再将队头的元素取出并销毁，代码运行结果如下

#include<stdio.h>
#include<assert.h>
#include<stdbool.h>
#include<stdlib.h>
#define N = 10;
typedef int QDateType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDateType data;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
}Queue;
//初始化队列
void QueueInit(Queue* pq);
//销毁队列
void QueueDestroy(Queue* pq);
//队尾入队列
void QueuePush(Queue* pq, QDateType x);
//队头出队列
void QueuePop(Queue* pq);
//获取队列头部元素
QDateType QueueFront(Queue* pq);
//获取队列尾部元素
QDateType QueueBack(Queue* pq);
//检测队列是否为空，为空返回非0，非空返回0
bool QueueEmpty(Queue* pq);
//获取队列有效元素个数
int QueueSize(Queue* pq);

void test() {
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	QueuePush(&q, 6);

	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n");
}
int main() {
	test();
	return 0;
}


//初始化队列
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;

}

//销毁队列
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}

//队尾入队列
void QueuePush(Queue* pq, QDateType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

//队头出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(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;
	}
}

//获取队列头部元素
QDateType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

//获取队列尾部元素
QDateType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

//检测队列是否为空，为空返回非0，非空返回0
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}

//获取队列有效元素个数
int QueueSize(Queue* pq)
{
	QNode* cur = pq->head;
	int size = 0;
	while (cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

最后是代码的运行结果