栈
1.1栈和队列
栈:一种特殊的线性表,其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶,另一端称为栈底。栈中的数据元素遵守后进先出LIFO(Last In First Out)的原则。
压栈:栈的插入操作叫做进栈/压栈/入栈,入数据在栈顶。
出栈:栈的删除操作叫做出栈。出数据也在栈顶。
1.2栈的实现
栈的实现一般可以使用数组或者链表实现,相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
#pragma once
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}ST;
void STInit(ST* pst);
void STDestroy(ST* pst);
void STPush(ST* pst, STDataType x);
void STPop(ST* pst);
STDataType STTop(ST* pst);
bool STEmpty(ST* pst);
int STSize(ST* pst);
void STInit(ST* pst)
{
assert(pst);
pst->a = NULL;
//pst->top = -1; // top 指向栈顶数据
pst->top = 0; // top 指向栈顶数据的下一个位置
pst->capacity = 0;
}
void STDestroy(ST* pst)
{
assert(pst);
free(pst->a);
pst->a = NULL;
pst->top = pst->capacity = 0;
}
void STPush(ST* pst, STDataType x)
{
if (pst->top == pst->capacity)
{
int newCapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
STDataType* tmp = (STDataType*)realloc(pst->a, newCapacity * sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
pst->a = tmp;
pst->capacity = newCapacity;
}
pst->a[pst->top] = x;
pst->top++;
}
void STPop(ST* pst)
{
assert(pst);
assert(!STEmpty(pst));
pst->top--;
}
STDataType STTop(ST* pst)
{
assert(pst);
assert(!STEmpty(pst));
return pst->a[pst->top - 1];
}
bool STEmpty(ST* pst)
{
assert(pst);
/*if (pst->top == 0)
{
return true;
}
else
{
return false;
}*/
return pst->top == 0;
}
int STSize(ST* pst)
{
assert(pst);
return pst->top;
}
队列
2.1队列的概念及结构
队列:只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出FIFO(First In First Out) 入队列:进行插入操作的一端称为队尾 出队列:进行删除操作的一端称为队头
2.2队列的实现
队列也可以数组和链表的结构实现,使用链表的结构实现更优一些,因为如果使用数组的结构,出队列在数组头上出数据,效率会比较低。
#pragma once
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int QDataType;
typedef struct QueueNode
{
struct QueueNode* next;
QDataType data;
}QNode;
typedef struct Queue
{
QNode* phead;
QNode* ptail;
int size;
}Queue;
void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);
#include"Queue.h"
void QueueInit(Queue* pq)
{
assert(pq);
pq->phead = NULL;
pq->ptail = NULL;
pq->size = 0;
}
void QueueDestroy(Queue* pq)
{
assert(pq);
QNode* cur = pq->phead;
while (cur)
{
QNode* next = cur->next;
free(cur);
cur = next;
}
pq->phead = pq->ptail = NULL;
pq->size = 0;
}
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
QNode* newnode = (QNode*)malloc(sizeof(QNode));
if (newnode == NULL)
{
perror("malloc fail\n");
return;
}
newnode->data = x;
newnode->next = NULL;
if (pq->ptail == NULL)
{
assert(pq->phead == NULL);
pq->phead = pq->ptail = newnode;
}
else
{
pq->ptail->next = newnode;
pq->ptail = newnode;
}
pq->size++;
}
void QueuePop(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
// 1、一个节点
// 2、多个节点
if (pq->phead->next == NULL)
{
free(pq->phead);
pq->phead = pq->ptail = NULL;
}
else
{
// 头删
QNode* next = pq->phead->next;
free(pq->phead);
pq->phead = next;
}
pq->size--;
}
QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->phead->data;
}
QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->ptail->data;
}
int QueueSize(Queue* pq)
{
assert(pq);
return pq->size;
}
bool QueueEmpty(Queue* pq)
{
assert(pq);
/*return pq->phead == NULL
&& pq->ptail == NULL;*/
return pq->size == 0;
}
2.3循环队列
扩展了解一下,实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。环形队列可以使用数组实现,也可以使用循环链表实现。
循环队列通常使用两个指针来表示队列的头部和尾部。其中,队头指针(front)指向队列的第一个元素,队尾指针(rear)指向队列最后一个元素的下一个位置。当队列为空时,front 和 rear 指向同一个位置。
循环队列的关键操作包括入队(enqueue)和出队(dequeue)操作。入队操作将元素添加到队尾,并将队尾指针后移;出队操作删除队头元素,并将队头指针后移。如果队列已满(即队尾指针的下一个位置等于队头指针),则无法执行入队操作;如果队列为空(即队头指针和队尾指针相等),则无法执行出队操作。
为了实现循环队列的循环特性,当队列的尾部指针已经达到数组的末尾时,如果队头指针指向数组的起始位置,则将队尾指针指向数组的起始位置,从而形成循环。这样可以充分利用数组空间,提高队列的效率。
循环队列具有一些优点,包括:
- 入队和出队操作的时间复杂度都是 O(1),即常数时间复杂度,与队列的大小无关。
- 对于固定大小的缓冲区,循环队列可以充分利用数组空间,避免了元素搬移的开销。
然而,循环队列也有一些限制和注意事项:
- 循环队列的容量是固定的,一旦创建后无法动态扩容。如果需要动态调整容量,可能需要重新创建一个更大的循环队列,并将元素从旧队列复制到新队列。
- 循环队列的容量必须是固定的缓冲区大小减一,这是为了区分队列是满还是空的条件。
- 在使用循环队列时,需要小心处理队列满和队列空的情况,避免出现错误的操作。
循环队列是一种特殊的队列,它可以在队列满时重新利用已经出队的空间。在循环队列中,我们通常需要维护一个队头指针和一个队尾指针。队头指针指向队列的第一个元素,队尾指针指向下一个插入的位置。当队尾指针到达队列的末尾并且还需要插入元素时,队尾指针会循环回到队列的开始。
一般来说,我们可以用以下方式来判断一个循环队列是否满了:
- 保留一个元素的空间不使用,也就是说,如果队列的最大大小是N,那么我们只将队列填充到N-1个元素。这样,如果队尾指针已经到达队列末尾并且队头指针没有指向队列开头,那么我们就知道队列已经满了。
- 使用一个额外的布尔变量来跟踪队列是否已满。当插入元素时,如果队尾指针到达队列末尾并且队头指针没有指向队列开头,那么我们就设置这个布尔变量为true。
在第一种方法中,如果队尾指针已经到达队列末尾并且队头指针没有指向队列开头,那么队列就满了。在第二种方法中,如果布尔变量为true,那么队列就满了。
这两种方法都有各自的优点和缺点。第一种方法的空间效率更高,因为它不需要额外的空间来存储布尔变量。但是,它的时间效率可能较低,因为每次插入元素时都需要检查队尾指针是否到达队列末尾。第二种方法的时间效率更高,因为它只需要检查一个布尔变量。但是,它的空间效率较低,因为它需要一个额外的布尔变量。
在计算循环队列是否满的情况下,第一种方法,也就是"保留一个元素的空间不使用"的方法,可以通过以下公式来判断:
如果 (rear + 1) % max_size == front
,那么队列已满。
这里 rear
是队尾指针,front
是队头指针,max_size
是队列的最大容量。这个公式的逻辑是,如果队尾指针加一(表示新元素将要插入的位置)然后对队列的最大容量取模(考虑到循环的情况)等于队头指针,那么队列就已经满了。
请注意,这个公式假设了队列的起始位置是从0开始的,如果你的实现是从1开始的,那么公式应该稍作修改。如果从1开始,那么队尾指针和队头指针都应该在每次操作时进行加一操作,即 rear = (rear + 1) % max_size
和 front = (front + 1) % max_size
,然后再判断 (rear + 1) % max_size == front
。