栈
1.1 栈的概念及结构
栈:一种特殊的线性表,其只允许在固定的一端进行插入和删除元素操作。**进行数据插入和删除操作的一端
称为栈顶,另一端称为栈底。**栈中的数据元素遵守后进先出LIFO(Last In First Out)的原则。
压栈:栈的插入操作叫做进栈/压栈/入栈,入数据在栈顶。
出栈:栈的删除操作叫做出栈。出数据也在栈顶。
从栈顶进,从栈顶出
这里理解栈不能和操作系统当中的栈区混淆
堆区是用来动态规划的(通常都很大,以G为单位),而栈区的空间则比较小(以M为单位)
所以在递归的过程中很容易出现栈溢出的现象
但是操作系统中的栈和数据结构中的栈有相似的性质:
操作系统的栈区中函数栈帧的创建也是先创建的后销毁,变量也是如此
数据结构中的栈是创建在堆区上的(堆区空间大,动态内存开辟)
1.2 栈的实现情况
通常情况下采取数组的形式设计栈,只要记住尾部位置即可,而且空间也是连续的,符合栈的性质
但是如果为了节省空间,也可以采取链表的方式
1.3 栈的代码实现
01 栈的定义和声明
typedef int STDataType;
typedef struct Stack
{
STDataType* data;
int capacity;
int top;
}ST;
data–动态开辟的数组 capacity–容量 top–栈顶
02 栈的初始化
void StackInit(ST* ps)
{
assert(ps);
ps->data = NULL;
ps->capacity = ps->top = 0;
}
将ps->data 置NULL
ps->capacity 和 ps->top都置为0
03 销毁接口
void StackDestroy(ST* ps)
{
assert(ps);
free(ps->data);
ps->data = NULL;
ps->capacity = ps->top = 0;
}
将动态开辟的data释放,capacity和top置0 即可
04 推入接口 Push
void StackPush(ST* ps, STDataType x)
{
assert(ps);
if (ps->capacity == ps->top)
{
int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
STDataType* tmp = realloc(ps->data, sizeof(ST) * newcapacity);
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
ps->data = tmp;
ps->capacity = newcapacity;
}
ps->data[ps->top] = x;
++ps->top;
}
栈因为其独特的性质,只能在栈顶插入元素,所以检查是否需要扩容也只需要在该模块进行(不需要再将其封装成CheckCapacity接口)
在ps->top的位置插入x,再让top++
05 弹出接口 Pop
void StackPop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));
--ps->top;
}
再弹出栈顶元素之前需要断言栈是否为空,直接–top即可
06 判空接口 Empty
bool StackEmpty(ST* ps)
{
assert(ps);
return ps->top == 0;
}
不需要采用 if / else 的方式直接return top是否等于0 (等于0 返回1 不等于0 返回0)
07 计算栈元素个数接口
int StackSize(ST* ps)
{
return ps->top;
}
当前top所在位置为栈顶元素的下一位,而返回个数正好是top
08 返回栈顶元素
STDataType StackTop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->data[ps->top - 1];
}
09 测试上述接口
在实现栈的过程中,不难发现有些接口过于简单,那有必要再将其封装成接口的形式嘛,直接在Test中实现不也可行嘛?
数据结构建议不要直接访问结构数据,一定要通过函数接口访问,主要是为了实现解耦 – 低耦合 高内聚。
当我们的栈实现完成后,调用栈的使用者不必关心我们内部如何实现,只需要调用接口即可。
1.4 栈的运用
有效的括号
该题要实现的就是括号的匹配问题,将左符号放在栈中,拿右符号与栈顶的左符号对应,若不匹配返回false
到这里代码通过了,是不是就完成了呢?
NO!NO!NO! 我们可以很明显的发现只有最后的return flag 之前对栈进行了销毁StackDestroy 。
而其他return 返回值,并没有释放使用的栈空间,就会导致内存泄漏的问题。
虽然该问题很容易忽视,但当大项目出现内存泄漏的时候排查起来会非常困难,所以在平时要养成习惯:在开辟空间后要及时释放
在每个return前加上StackDestroy(&st);
即可
队列
2.1 队列的概念及结构
2.2 队列的实现情况
队列也可以数组和链表的结构实现,使用链表的结构实现更优一些。
因为如果使用数组的结构,出队列在数组头上出数据,就要进行挪动数据,将后面的数据往前挪 ,时间复杂度:O(N)
2.3 队列的代码实现
01 队列的定义与声明
typedef int QDataType;
typedef struct QNode
{
struct QNode* next;
QDataType data;
}QNode;
typedef struct Queue
{
QNode* head;
QNode* tail;
int size;
}Queue;
队列结点QNode
队列结构体Queue包含 结点指针head指向队头,结点指针tail指向队尾,size计算队列长度
两层结构体
将队列单独封装成结构体的好处,接口可以不需要使用到二级指针QNode**
,只需要使用Queue*
改变其中的内容即可
(如果不封装结构体,修改QNode* head 和QNode* tail 所指向内容需要使用二级指针QNode**
)
02 初始化队列
void QueueInit(Queue* pq)
{
assert(pq);
pq->head = pq->tail = NULL;
pq->size = 0;
}
03 销毁接口
void QueueDestroy(Queue* pq)
{
assert(pq);
QNode* cur = pq->head;
while (cur)
{
QNode* del = cur;
cur = cur->next;
free(del);
del = NULL;
}
pq->head = pq->tail = NULL;
pq->size = 0;
}
队列是通过链表的形式实现的,从head结点开始遍历即可
04 插入接口 Push
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
QNode* newnode = (QNode*)malloc(sizeof(QNode));
if (newnode == NULL)
{
perror("malloc fail");
exit(-1);
}
else
{
newnode->data = x;
newnode->next = NULL;
}
if (pq->tail == NULL)
{
pq->head = pq->tail = newnode;
}
else
{
pq->tail->next = newnode;
pq->tail = newnode;
}
pq->size++;
}
队列的特性:只能在队尾插入数据
创建newnode 链接进队列,
若队列为空 newnode 为队头/队尾
若队列不为空 newnode 链接到tail 之后,成为新的队尾
05 弹出接口 Pop
void QueuePop(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
if (pq->head->next == NULL)
{
free(pq->head);
pq->head = pq->tail = NULL;
}
else
{
QNode* del = pq->head;
pq->head = pq->head->next;
free(del);
del = NULL;
}
pq->size--;
}
队列的特性:只能从队头弹出数据
在弹出前,先断言队列是否为空,如果队列中只有一个元素,弹出后将head和tail置NULL
如果队列中还存在其他元素,找到下一结点,使之成为新结点
06 返回队头数据
QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->head->data;
}
07 返回队尾数据
QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->tail->data;
}
在返回数据前先判断队列是否为空
08 判断是否为空
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->head == NULL && pq->tail == NULL;
}
09 队列长度
int QueueSize(Queue* pq)
{
assert(pq);
return pq->size;
}
10 测试上述接口
void TestQueue()
{
Queue q;
QueueInit(&q);
QueuePush(&q, 1);
QueuePush(&q, 2);
QueuePush(&q, 3);
QueuePush(&q, 4);
printf("%d ", QueueFront(&q));
QueuePop(&q);
QueuePush(&q, 5);
QueuePush(&q, 6);
printf("%d ", QueueFront(&q));
QueuePop(&q);
printf("\n当前队列长度:%d\n", QueueSize(&q));
while (!QueueEmpty(&q))
{
printf("%d ", QueueFront(&q));
QueuePop(&q);
}
printf("\n");
QueueDestroy(&q);
}
int main()
{
TestQueue();
return 0;
}
队列和栈的出数据顺序
队列的出数据顺序只有一种,因为队列只能从队头弹出数据,即使数据存放在队列中,队列最终的出数据顺序还是只存在顺序的情况。
而栈只能从队尾弹出数据,所以可以在推入后立马弹出,也可以选择存放在栈中,所以栈的出数据顺序可以多种多样。
栈和队列的OJ题
1. 用队列实现栈
具体代码实现:
// ...
// 前面部分为队列的实现代码
// 将两个队列封装在结构体当中 该结构体为匿名结构体
typedef struct {
Queue q1;
Queue q2;
} MyStack;
MyStack* myStackCreate() {
// 创建双队列结构体
MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
//对结构体中的双队列进行初始化
QueueInit(&obj->q1);
QueueInit(&obj->q2);
return obj;
}
void myStackPush(MyStack* obj, int x) {
//在其中一个队列中插入数据即可
//q1 非空 插q1
if(!QueueEmpty(&obj->q1))
{
QueuePush(&obj->q1,x);
}
//空 插q2
else
{
QueuePush(&obj->q2,x);
}
}
// 弹出并返回栈顶元素
int myStackPop(MyStack* obj) {
//假设q1为空 q2为非空
Queue* empty = &obj->q1;
Queue* nonempty = &obj->q2;
if(!QueueEmpty(&obj->q1))
{
empty = &obj->q2;
nonempty = &obj->q1;
}
while(QueueSize(nonempty) > 1)
{
QueuePush(empty,QueueFront(nonempty));
QueuePop(nonempty);
}
int top = QueueBack(nonempty);
QueuePop(nonempty);
return top;
}
int myStackTop(MyStack* obj) {
//假设q1为空 q2为非空
Queue* empty = &obj->q1;
Queue* nonempty = &obj->q2;
if(!QueueEmpty(&obj->q1))
{
empty = &obj->q2;
nonempty = &obj->q1;
}
return QueueBack(nonempty);
}
bool myStackEmpty(MyStack* obj) {
return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}
void myStackFree(MyStack* obj) {
QueueDestroy(&obj->q1);
QueueDestroy(&obj->q2);
free(obj);
}
在代码实现过程中出现的问题:
2. 用栈实现队列
// ...
// 前面代码部分为栈的实现代码
typedef struct {
ST pushST;
ST popST;
} MyQueue;
MyQueue* myQueueCreate() {
MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
StackInit(&obj->pushST);
StackInit(&obj->popST);
return obj;
}
void myQueuePush(MyQueue* obj, int x) {
StackPush(&obj->pushST,x);
}
void PushSTToPopST(ST* PushST,ST* PopST)
{
while(!StackEmpty(PushST))
{
StackPush(PopST,StackTop(PushST));
StackPop(PushST);
}
}
int myQueuePop(MyQueue* obj) {
if(StackEmpty(&obj->popST))
{
PushSTToPopST(&obj->pushST,&obj->popST);
}
int tmp = StackTop(&obj->popST);
StackPop(&obj->popST);
return tmp;
}
int myQueuePeek(MyQueue* obj) {
if(StackEmpty(&obj->popST))
{
PushSTToPopST(&obj->pushST,&obj->popST);
}
return StackTop(&obj->popST);
}
bool myQueueEmpty(MyQueue* obj) {
return StackEmpty(&obj->popST) && StackEmpty(&obj->pushST);
}
void myQueueFree(MyQueue* obj) {
StackDestroy(&obj->popST);
StackDestroy(&obj->pushST);
free(obj);
}
3. 设计循环队列
逻辑结构:循环队列 物理结构:采用数组的方式存储(也可以用链表,虽然循环链表更符合逻辑结构,但是链表初始化链接…相对麻烦)
typedef struct {
int N; // N个空间
int* a; // a数组
int back;// 队尾的下一位
int front;// 队头
} MyCircularQueue;
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
// 结构体判空
if (obj == NULL)
{
perror("MyCircularQueue malloc fail");
exit(-1);
}
// 数组长度设计为k+1
obj->a = (int*)malloc((k + 1) * sizeof(int));
// 数组判空
if (obj->a == NULL)
{
perror("arror malloc fail");
exit(-1);
}
obj->back = obj->front = 0;
//数组长度
obj->N = k + 1;
return obj;
}