xdm这玩意我不会导入，只能截图了。 

目录

栈篇

1.1栈

1.2.栈操作数据元素的两种动作：

2.代码实现

2.1初始化和销毁

2.2插入

2.3删除和判空

2.4返回栈顶值,计算栈长

队列篇

3.1队列

4.代码实现

4.1初始化和销毁和判空

4.2入列

4.3出列

4.4返回对首和队尾

---

栈篇

1.1栈

栈，线性表的一种特殊的存储结构。与学习过的线性表的不同之处在于栈只能从表的固定一端对数据进行插入和删除操作，另一端是封死的。由于栈只有一边开口存取数据，称开口的那一端为“栈顶”，封死的那一端为“栈底”（类似于盛水的木桶，从哪进去的最后还得从哪出来）。

1.2.栈操作数据元素的两种动作：

1. 数据元素用栈的数据结构存储起来，称为“入栈”，也叫“压栈”。
2. 数据元素由于某种原因需要从栈结构中提取出来，称为“出栈”，也叫“弹栈”。

注意：栈遵循先进后出原则

1.3.栈的表示方式

既然栈也是线性表，那么它就同样有线性表的两种表示形式： 顺序（数组）和 链式栈。

但是，栈需要进行尾部的插入和删除，所以用顺序表实现比链表实现更好。

2.代码实现

接下来就来实现这几大功能

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

typedef int SLDateType;
typedef struct Stack
{
	SLDateType* a;
	int top;     //栈顶
	int capacity;   //内存
}ST;

//初始化
void StackInit(ST* ps);

//销毁
void StackDestroy(ST* ps);

//插入
void StackPush(ST* ps, SLDateType x);

//删除
void StackPop(ST* ps);

//返回栈顶值
void StackTop(ST* ps);

//判断是否为空
bool StackEmpty(ST* ps);

//计算栈长
int StackSize(ST* ps);

是不是你们的教科书上用的是双指针，或者，这个栈顶元素top也用指针了。但是这个还是不用指针更好一点，这个top既能表示栈顶，又能表示此时栈中所存储的数据个数，用途更多了。

2.1初始化和销毁

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

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

初始化和销毁就这两步啊给指针a赋值NULL，给剩下俩赋值为0，

 销毁就是释放指针，给那俩赋值为0。

2.2插入

//插入
void StackPush(ST* ps, SLDateType x)
{
	assert(ps);
	if (ps->top == ps->capacity)//判断容量
	{
		int newcapacity = (ps->capacity == 0 ? 4 : 2 * ps->capacity);//扩容后的容量
		SLDateType* tmp = realloc(ps->a, sizeof(SLDateType) * newcapacity);//扩容
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->capacity = newcapacity;
		ps->a = tmp;
	}
	ps->a[ps->top] = x ;//压入数据
	ps->top++;
}

最后一步压入数据是往结构体的a中压入的，又因为a是结构体指针，所以a中有top，所以把要插入的值存在top中，然后top++。

至于那个ps->a=tmp是把开辟好的地址给ps->a。 

2.3删除和判空

//删除
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

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

注意bool的头文件<stdbool.h>

2.4返回栈顶值,计算栈长

//返回栈顶值
SLDateType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
 }

//计算栈长
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

2.5全部代码 

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; //容量
}ST;

//1.初始化栈
void StackInit(ST* ps);

//2.销毁栈
void StackDestory(ST* ps);

//3.压栈
void StackPush(ST* ps, STDataType x);

//4.出栈
void StackPop(ST* ps);

//5.判空
bool StackEmpty(ST* ps);

//6.访问栈顶数据
STDataType StackTop(ST* ps);

//7.有效元素个数
int StackSize(ST* ps);

Stack.c 

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"
//1.初始化栈
void StackInit(ST* ps)
{
	assert(ps); 
	ps->a = NULL;                  //栈顶元素数值
	ps->top = 0;                   //栈顶指针指向0
	ps->capacity = 0;              //栈的容量大小
}

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

//3.压栈
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//如果栈满了，考虑扩容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2; //检测容量
		ps->a = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (ps->a == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		ps->capacity = newcapacity; //更新容量
	}
	ps->a[ps->top] = x;//将数据压进去
	ps->top++;//栈顶上移
}
//4.出栈
void StackPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}

//5.判空
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0; //如果top为0，那么就为真，即返回
}

//6.访问栈顶数据
STDataType StackTop(ST* ps)
{
	assert(ps);
	return ps->a[ps->top - 1]; //top-1的位置才为栈顶的元素
}

//7.有效元素个数
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

 Test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"
void TestStack()
{
	ST st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);
	while (!StackEmpty(&st))
	{
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}
	printf("\n");
	StackDestory(&st);
}
int main()
{
	TestStack();
	return 0;
}

 

---

---

队列篇

3.1队列

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

注意:队列是先进先出。

 一般我们用链来实现队列。

4.代码实现

typedef int QDataType;
 
typedef struct QueueNode//链表
{
	QDataType data;
	struct QueueNode* next;
}QNode;
 
typedef struct Queue//队列
{
	QNode* head;
	QNode* tail;
}Queue;

4.1初始化和销毁和判空

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

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

//判空
int QueueEmpty(Queue* pd)
{
	if (pd->head == NULL)
	{
		return 1;
	}
	else
		return 0;
}

4.2入列

//入列
void QueuePush(Queue* pd, QDateType x)//入列
{
	assert(pd);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		printf("malloc:falue");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	//一个没有就进行插入
	if (pd->tail == NULL)
	{
		pd->head = pd->tail = newnode;
	}

	else
	{
		pd->tail->next = newnode;
		pd->tail = newnode;
	}
	
}

4.3出列

//出列
void QueuePop(Queue* pd)
{
	assert(pd);
	assert(!QueueEmpty(pd));
	if (pd->head->next == NULL)
	{
		free(pd->head);
		pd->head = pd->tail = NULL;
	}
	else
	{
		QNode* next = pd->head->next;   //保存下一个节点地址，防止找不到
		free(pd->head);
		pd->head = next;
	}
}

4.4返回对首和队尾

//返回队首
void QueueFront(Queue* pd)
{
	assert(pd);
	assert(!QueueEmpty(pd));
	return pd->head->data;
}

//返回队尾
void QueueBack(Queue* pd)
{
	assert(pd);
	assert(!QueueEmpty(pd));
	return pd->tail->data;
}

这个返回首尾是看一位大佬的代码的临时启发，希望对各位有用。

一些代码没加备注，我认为各位都学到了这了，这些代码随便就来，就没写来凑字了。

总结：栈和队列都能用顺序表（数组）和链表来表示。再想想，这俩不就是链表的特殊情况吗，栈是后进先出，队列是先进先出，而链表（单，循环）是啥时候进出都可以，这不就是长方形里的正方形吗。