1.栈的模拟实现
1.1栈的概念及结构
-
栈:一种特殊的线性表,其只允许在固定的一端进行插入和删除元素操作。**进行数据插入和删除操作的一端称为栈顶,另一端称为栈底。**栈中的数据元素遵守后进先出LIFO(Last In First Out)的原则。
-
压栈:栈的插入操作叫做进栈/压栈/入栈,入数据在栈顶。
-
出栈:栈的删除操作叫做出栈。出数据也在栈顶。
1.2栈的模拟实现
- 栈的实现一般可以使用数组或者链表实现,相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
1.栈的结构类型声明
// stack n./stæk/ n.栈;一堆
typedef int STDataType;
typedef struct Stack
{
// 数组地址就是a(a指向这个栈在堆上面的存储空间)
STDataType* a;
// top就是栈顶的下标
int top;
// capacity就是栈的容量
int capacity;
}ST; // 将这个结构体类型重新定义为ST
2.栈的初始化
void StackInit(ST* ps)
{
assert(ps);
// 将数组地址初始化为空(这个栈在堆上面的存储空间)
ps->a = NULL;
ps->top = ps->capacity = 0;
}
3.栈的销毁
void StackDestroy(ST* ps)
{
assert(ps);
// 销毁这个栈,首先要释放这个栈在堆上面的存储空间
free(ps->a);
// 为了防止野指针,将a置为空
ps->a = NULL;
ps->capacity = ps->top = 0;
}
4.进栈/压栈/入栈
void StackPush(ST* ps, STDataType x)
{
assert(ps);
// 在将一个数据入栈之前,需要先检查当前数组的容量够不够
// 如果ps->top == ps->capacity为真,说明当前数组已经满了,如果想要继续插入,那么就需要对当前数组进行扩容
if (ps->top == ps->capacity)
{
// 如果ps->capacity == 0为真,也就是数组的容量为0,那么新的容量为4
// 如果ps->capacity == 0为假,那么数组新的容量为2倍的旧容量
int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
// 使用realloc函数进行扩容
// 此处,必须将返回的地址给到tmp,而不是直接给到ps->a
// 这是为了防止扩容失败,扩容失败,会返回空指针,那么ps->a就会变为空指针,这会造成内存泄漏
STDataType* tmp = (STDataType*)realloc(ps->a, newCapacity*sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
// a为扩容后数组的地址
ps->a = tmp;
// capacity为扩容后数组新的容量
ps->capacity = newCapacity;
}
// 将x入栈
ps->a[ps->top] = x;
ps->top++;
}
5.检查栈是否为空
bool StackEmpty(ST* ps)
{
assert(ps);
// 如果ps->top == 0为真,说明栈是空的
return ps->top == 0;
}
6.出栈
void StackPop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));
// 出栈缩小数组的下标就可以
--ps->top;
}
7.取栈顶元素
STDataType StackTop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));
// 下标ps->top - 1对应的就是栈顶元素
return ps->a[ps->top - 1];
}
8.栈的大小
int StackSize(ST* ps)
{
assert(ps);
// top下标对应的就是栈元素的个数
return ps->top;
}
1.3栈的完整实现
- Stack.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}ST;
void StackInit(ST* ps);
void StackDestroy(ST* ps);
void StackPush(ST* ps, STDataType x);
void StackPop(ST* ps);
STDataType StackTop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);
- Stack.c
#include "Stack.h"
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->capacity = ps->top = 0;
}
void StackPush(ST* ps, STDataType x)
{
assert(ps);
//
if (ps->top == ps->capacity)
{
int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
STDataType* tmp = (STDataType*)realloc(ps->a, newCapacity * sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
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;
}
STDataType StackTop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->a[ps->top - 1];
}
bool StackEmpty(ST* ps)
{
assert(ps);
return ps->top == 0;
}
int StackSize(ST* ps)
{
assert(ps);
return ps->top;
}
- main.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include "Stack.h"
// 解耦 -- 低耦合 高内聚
// 数据结构建议不要直接访问结构数据,一定要通过函数接口访问
void TestStack()
{
ST st;
StackInit(&st);
StackPush(&st, 1);
StackPush(&st, 2);
StackPush(&st, 3);
printf("%d\n", StackTop(&st));
StackPop(&st);
printf("%d\n", StackTop(&st));
StackPop(&st);
StackPush(&st, 4);
StackPush(&st, 5);
while (!StackEmpty(&st))
{
printf("%d ", StackTop(&st));
StackPop(&st);
}
printf("\n");
}
int main()
{
TestStack();
return 0;
}
2.队列
2.1队列的概念及结构
- 队列:只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出FIFO(First In First Out) 入队列:进行插入操作的一端称为队尾 ; 出队列:进行删除操作的一端称为队头
2.2队列的实现
- 队列也可以数组和链表的结构实现,使用链表的结构实现更优一些,因为如果使用数组的结构,出队列在数组头上出数据,效率会比较低。
1.队列的结构体声明
// 队列节点的结构体
typedef int QDataType;
typedef struct QueueNode
{
// 指向下一个节点的指针
struct QueueNode* next;
// 这个节点存储的数据表
QDataType data;
}QNode; // 将这个结构体重新定义为QNode
//队列的结构体(封装队列的头指针和尾指针)
typedef struct Queue
{
// 头节点
QNode* head;
// 尾节点
QNode* tail;
//队列节点的数量
int size;
}Queue; // 将这个结构体重新定义为Queue
2.队列的初始化
void QueueInit(Queue* pq)
{
assert(pq);
// 对队列的头指针,尾指针,和队列节点数量进行初始化
pq->head = pq->tail = NULL;
pq->size = 0;
}
3.队列的销毁
void QueueDestroy(Queue* pq)
{
assert(pq);
// 从队列的头节点开始,对队列中的每一个节点进行销毁
QNode* cur = pq->head;
while (cur)
{
QNode* del = cur;
free(del);
// 迭代
cur = cur->next;
}
// 设置为空指针,防止产生野指针
pq->head = pq->tail = NULL;
}
4.入队
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
{
// 当链表不为空时
// 1.尾节点指向这个新节点
pq->tail->next = newnode;
// 2.这个新节点成为新的尾节点
pq->tail = newnode;
}
// 队列中的节点数量增加
pq->size++;
}
5.检查队列是否为空
bool QueueEmpty(Queue* pq)
{
assert(pq);
// 当尾节点指针和头节点指针都为空,说明队列为空
return pq->head == NULL && pq->tail == NULL;
}
6.出队
// 将一个节点出队,也就是将单链表进行头删
void QueuePop(Queue* pq)
{
assert(pq);
// 首先要确保这个链表不是空链表
assert(!QueueEmpty(pq));
// 此时,可以保证链表不是空链表
// 那么就分为两种情况
// 情况1:链表只剩下一个头节点,释放掉这个头节点后,需要将链表的头节点和尾节点置空
// 情况2:链表节点的数量大于等于2,释放掉头节点之后,头节点后的节点pq->head->next成为新的头节点
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;
}
// 链表中,节点的数量减小1个
pq->size--;
}
7.取队头元素
// 取队头元素,也就是返回链表头节点的数据
QDataType QueueFront(Queue* pq)
{
assert(pq);
// 要保证链表不是空链表
assert(!QueueEmpty(pq));
return pq->head->data;
}
8.取队尾元素
// 返回队尾节点的数据
QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->tail->data;
}
9.队列元素的个数
// 返回链表节点的个数
int QueueSize(Queue* pq)
{
assert(pq);
return pq->size;
}
2.3 队列的模拟实现
- Queue.h
#pragma once
#include <stdio.h>
#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* head;
QNode* tail;
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);
bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);
- Queue.c
#include "Queue.h"
void QueueInit(Queue* pq)
{
assert(pq);
pq->head = pq->tail = NULL;
pq->size = 0;
}
void QueueDestroy(Queue* pq)
{
assert(pq);
QNode* cur = pq->head;
while (cur)
{
QNode* del = cur;
cur = cur->next;
free(del);
}
pq->head = pq->tail = NULL;
}
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++;
}
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--;
}
QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->tail->data;
}
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->head == NULL && pq->tail == NULL;
}
int QueueSize(Queue* pq)
{
assert(pq);
return pq->size;
}
- main.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include "Queue.h"
void TestQueue()
{
Queue q;
QueueInit(&q);
QueuePush(&q, 1);
QueuePush(&q, 2);
QueuePush(&q, 3);
printf("%d ", QueueFront(&q));
QueuePop(&q);
printf("%d ", QueueFront(&q));
QueuePop(&q);
QueuePush(&q, 4);
QueuePush(&q, 4);
QueuePush(&q, 4);
while (!QueueEmpty(&q))
{
printf("%d ", QueueFront(&q));
QueuePop(&q);
}
printf("\n");
QueueDestroy(&q);
}
int main()
{
TestQueue();
return 0;
}
3.栈和队列面试题
1.括号匹配问题。OJ链接
// 自定义的栈的实现(后续可以考虑使用c++来完成这道题目,就不需要自己去写这个栈了)
// 函数声明
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}ST;
void StackInit(ST* ps);
void StackDestroy(ST* ps);
void StackPush(ST* ps, STDataType x);
void StackPop(ST* ps);
STDataType StackTop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);
// 函数实现
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->capacity = ps->top = 0;
}
void StackPush(ST* ps, STDataType x)
{
assert(ps);
// 扩容
if (ps->top == ps->capacity)
{
int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
STDataType* tmp = (STDataType*)realloc(ps->a, newCapacity*sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
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;
}
STDataType StackTop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->a[ps->top - 1];
}
bool StackEmpty(ST* ps)
{
assert(ps);
return ps->top == 0;
}
int StackSize(ST* ps)
{
assert(ps);
return ps->top;
}
bool isValid(char * s){
// 创建一个栈对象
ST st;
// 初始化栈
StackInit(&st);
// *s为空时,说明所有的字符都已经判断过了
while(*s)
{
// 1.如果是左括号,不论那种类型的左括号,就将其入栈
if(*s == '(' || *s == '[' || *s == '{')
{
StackPush(&st, *s);
}
else
{
// 2.开始匹配,现在的字符对应的必然是右括号
// 情况一:如果栈顶元素为空,说明括号数量不匹配;
// 情况二:那么此时栈顶的元素必然是与其对应的左括号,如果不是,说明括号不匹配
// 注:根据题目要求可知,不同类型的左右括号一一对应,且匹配顺序也是对应的
if(StackEmpty(&st))
{
// 防止内存泄漏,销毁栈在堆上面开辟的空间
StackDestroy(&st);
// 不匹配,则返回false
return false;
}
// 情况二
// 取栈顶元素
char top = StackTop(&st);
// 取出之后,将其出栈,方便下一次循环,取下一个元素
StackPop(&st);
// 这三个条件,满足一个,则说明不匹配,返回false
if(( *s == ')' && top != '(' )
|| ( *s == ']' && top != '[' )
|| ( *s == '}' && top != '{' ))
{
// 防止内存泄漏,销毁栈在堆上面开辟的空间
StackDestroy(&st);
// 不匹配,则返回false
return false;
}
}
// 迭代
// 字符串到'\0'停止
++s;
}
// 将右括号与栈里面的左括号匹配之后,如果栈里面还有左括号,说明括号数量不匹配
// 如果栈为空,说明匹配正确,返回真
// 则flag为真,否则为假
bool flag = StackEmpty(&st);
// 最后要将栈销毁,防止内存泄漏
StackDestroy(&st);
return flag;
}
2. 用队列实现栈。OJ链接
// 自定义的栈的实现(后续可以考虑使用c++来完成这道题目,就不需要自己去写这个栈了)
// 函数声明
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}ST;
void StackInit(ST* ps);
void StackDestroy(ST* ps);
void StackPush(ST* ps, STDataType x);
void StackPop(ST* ps);
STDataType StackTop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);
// 函数实现
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->capacity = ps->top = 0;
}
void StackPush(ST* ps, STDataType x)
{
assert(ps);
// 扩容
if (ps->top == ps->capacity)
{
int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
STDataType* tmp = (STDataType*)realloc(ps->a, newCapacity*sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
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;
}
STDataType StackTop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->a[ps->top - 1];
}
bool StackEmpty(ST* ps)
{
assert(ps);
return ps->top == 0;
}
int StackSize(ST* ps)
{
assert(ps);
return ps->top;
}
// 用两个队列,实现一个先入后出的栈
// 匿名类型结构体,只能够使用一次
typedef struct {
// 1号队列
Queue q1;
// 2号队列
Queue q2;
} MyStack;
// 创建一个栈对象
MyStack* myStackCreate() {
// 申请存放两个队列变量的空间;object n.目标,对象
// obj必须在堆上面申请空间,如果在栈区上面,出了局部作用域队列空间就会被销毁
// 使用malloc申请一个栈对象大小的空间,并返回这个空间的地址给到obj
MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
// 初始化两个队列
QueueInit(&obj->q1);
QueueInit(&obj->q2);
// 返回栈对象的地址
return obj;
}
// 栈对象的插入功能
void myStackPush(MyStack* obj, int x) {
// 将数据压栈到非空的队列
// 第一次压栈,因为两个队列都是空队列,所以会压栈道队列2中
if(!QueueEmpty(&obj->q1))
{
QueuePush(&obj->q1, x);
}
else
{
QueuePush(&obj->q2, x);
}
}
// 栈的出栈功能
int myStackPop(MyStack* obj) {
// 将非空队列中的前(n-1)个数据出队,放入另一个空队列,再将剩余的唯一数据出队
// 步骤1:假设q1是空队列,q2是非空队列
Queue* Empty = &obj->q1;
Queue* nonEmpty = &obj->q2;
// 如果!QueueEmpty(&obj->q1)为真,说明假设错误
if(!QueueEmpty(&obj->q1))
{
Empty = &obj->q2;
nonEmpty = &obj->q1;
}
// 此时Empty必然是空队列,nonEmpty必然是非空队列
// 步骤2:将非空队列中的前(n-1)个数据出队,放入另一个空队列
// 非空队列中节点数量还大于1,则循环继续
while(QueueSize(nonEmpty) > 1)
{
// 通过QueueFront(nonEmpty),取非空队列的头节点
// 通过QueuePush()将非空队列的头节点,放入道空队列中(入队到空队列)
QueuePush(Empty,QueueFront(nonEmpty));
// 将非空队列的头节点出队
QueuePop(nonEmpty);
}
// 再将剩余的一个数据出队,并将其返回(对应栈的出栈)
int top = QueueFront(nonEmpty);
QueuePop(nonEmpty);
return top;
}
// 拿到栈顶元素
int myStackTop(MyStack* obj) {
// 栈顶元素,就是非空队列尾节点的数据
// 将非空队列tail指向的数据返回
if(!QueueEmpty(&obj->q1))
{
// 通过QueueBack(&obj->q1)取尾节点的数据
return QueueBack(&obj->q1);
}
else
{
return QueueBack(&obj->q2);
}
}
// 判断栈是否为空
bool myStackEmpty(MyStack* obj) {
// 当两个队列都为空时,栈为空
return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}
// 释放栈空间
void myStackFree(MyStack* obj) {
// 先释放申请的两个队列的空间
QueueDestroy(&obj->q1);
QueueDestroy(&obj->q1);
// 再释放存放两个队列变量的空间
free(obj);
}
3. 用栈实现队列。OJ链接
// 自定义的栈的实现(后续可以考虑使用c++来完成这道题目,就不需要自己去写这个栈了)
// 函数声明
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}ST;
void StackInit(ST* ps);
void StackDestroy(ST* ps);
void StackPush(ST* ps, STDataType x);
void StackPop(ST* ps);
STDataType StackTop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);
// 函数实现
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->capacity = ps->top = 0;
}
void StackPush(ST* ps, STDataType x)
{
assert(ps);
// 扩容
if (ps->top == ps->capacity)
{
int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
STDataType* tmp = (STDataType*)realloc(ps->a, newCapacity*sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
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;
}
STDataType StackTop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->a[ps->top - 1];
}
bool StackEmpty(ST* ps)
{
assert(ps);
return ps->top == 0;
}
int StackSize(ST* ps)
{
assert(ps);
return ps->top;
}
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) {
// 入队,也就是将数据全部压栈到PushST
StackPush(&obj->PushST, x);
}
// 由于出队和取队顶元素,都需要检查PopST是否为空栈,
// 如果为空栈,需要将PushST的数据导入到PopST
// 因此单独写一个函数来封装
void PushSTToPopST(MyQueue* obj)
{
if(StackEmpty(&obj->PopST))
{
while(!StackEmpty(&obj->PushST))
{
// 将PushST的数据导入PopST之后,PushST也要将其出栈
StackPush(&obj->PopST, StackTop(&obj->PushST));
StackPop(&obj->PushST);
}
}
}
int myQueuePop(MyQueue* obj) {
// 先判断是否需要导数据
PushSTToPopST(obj);
// 出队也就是PopST出栈
int front = StackTop(&obj->PopST);
StackPop(&obj->PopST);
return front;
}
int myQueuePeek(MyQueue* obj) {
// 先判断是否需要导数据
PushSTToPopST(obj);
// 取队头数据,也就是取PopST的栈顶数据
return StackTop(&obj->PopST);
}
bool myQueueEmpty(MyQueue* obj) {
// 队列为空,也就是两个栈都为空
return StackEmpty(&obj->PushST) && StackEmpty(&obj->PopST);
}
void myQueueFree(MyQueue* obj) {
// 先释放两个栈申请的空间
StackDestroy(&obj->PushST);
StackDestroy(&obj->PopST);
// 在释放存放栈的变量的空间
free(obj);
}
4. 设计循环队列。OJ链接
// 循环队列的结构体
typedef struct {
// a是指向循环列队在堆上开辟空间的指针
int* a;
// front是队列的队头的下标
int front;
// rear n.后部,背部
// rear是队列尾元素的下一个元素的下标
// 注:rear所在的空间,是不存储数据的,只是用来判断队列是否满了
int rear;
// 队列空间的个数
int N ;
} MyCircularQueue;
// 创建循环队列(并进行初始化)
MyCircularQueue* myCircularQueueCreate(int k) {
// 创建一个循环队列对象大小的空间,并返回这个空间的地址
MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
// 再申请存放队列的空间,需要在固定队列长度的基础上再多开一个空间
obj->N = k + 1;
obj->front = obj->rear = 0;
// 队列的大小为obj->N个int大小的空间
obj->a = (int*)malloc(sizeof(int)*obj->N);
// 返回循环队列
return obj;
}
// 判断循环队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
// 当front == rear为真时,队列为空
return obj->front == obj->rear;
}
// 判断循环队列是否满了
bool myCircularQueueIsFull(MyCircularQueue* obj) {
// 方案1:当(rear+1)%N == front时,队列已满
return (obj->rear+1) % obj->N == obj->front;
/*
// 方案2:单独处理rear == k的情况
if(obj->rear == obj->N - 1)
{
return obj->front == 0;
}
else
{
return obj->rear + 1 == obj->front;
}
*/
}
// 循环队列入队
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
// 第一步:先检查队列是否已满
if(myCircularQueueIsFull(obj))
{
return false;
}
// 第二步:在rear处,插入并更新rear
obj->a[obj->rear] = value;
obj->rear = (obj->rear + 1) % obj->N;
return true;
}
// 循环队列出队
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
// 第一步:先检查队列是否为空
if(myCircularQueueIsEmpty(obj))
return false;
// 第二步:将front位置处的数据出队,并更新front
obj->front = (obj->front+1) % obj->N;
return true;
}
// 取队列的队头元素
int myCircularQueueFront(MyCircularQueue* obj) {
// 取队首元素,也就是取front位置处的元素
// 第一步:检查队列是否为空
if(myCircularQueueIsEmpty(obj))
return -1;
// 第二步:取队头元素返回
return obj->a[obj->front];
}
// 取队列的队尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
// 取队尾元素也就是取rear前一个位置的元素
// 第一步:检查队列是否为空
if(myCircularQueueIsEmpty(obj))
return -1;
// 第二步:取队尾元素,并返回
return obj->a[(obj->rear - 1 + obj->N) % obj->N];
}
// 释放循环队列
void myCircularQueueFree(MyCircularQueue* obj) {
// 先释放队列的空间
free(obj->a);
obj->a =NULL;
// 再释放存放队列变量的空间
free(obj);
}
4.概念选择题
1.一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈,然后再依次出栈,则元素出栈的顺序是( )。
A 12345ABCDE
B EDCBA54321
C ABCDE12345
D 54321EDCBA
2.若进栈序列为 1,2,3,4 ,进栈过程中可以出栈,则下列不可能的一个出栈序列是()
A 1,4,3,2
B 2,3,4,1
C 3,1,4,2
D 3,4,2,1
选项A:入栈1,出栈1;入栈2,3,4 出栈4,3,2
选项B:入栈1,2;出栈2,入栈3,出栈3,入栈4,出栈4,再出栈1;
选项D:入栈1,2,3;出栈3,入栈4,出栈4,再出栈1,2;
3.循环队列的存储空间为 Q(1:100) ,初始状态为 front=rear=100 。经过一系列正常的入队与退队操作后, front=rear=99 ,则循环队列中的元素个数为( )
A 1
B 2
C 99
D 0或者100
4.以下( )不是队列的基本运算?
A 从队尾插入一个新元素
B 从队列中删除第i个元素
C 判断一个队列是否为空
D 读取队头元素的值
5.现有一循环队列,其队头指针为front,队尾指针为rear;循环队列长度为N(也就是队列有N个空间)。其队内有效长度为?(假设队尾的空间不存放数据)
A (rear - front + N) % N + 1
B (rear - front + N) % N
C ear - front) % (N + 1)
D (rear - front + N) % (N - 1)
答案:
1.B
2.C
3.D
4.B
5.B