栈和队列详解（C语言）

最新推荐文章于 2023-04-16 13:21:19 发布

格雷福斯-张三

最新推荐文章于 2023-04-16 13:21:19 发布

阅读量629

点赞数 2

文章标签： c语言 c++ java

本文链接：https://blog.csdn.net/Raikkonen_love/article/details/127933694

版权

栈和队列

栈
- 队列
- - 力扣笔试题

栈

栈是什么，栈是一种数据存储的结构，采用的是先进后出，后进先出的原则，就好像是弹匣里的子弹，比如说一个弹匣有30发容量，那第一个发压进去的子弹肯定是最后一个射出的，最先射出的子弹肯定是最后压入弹匣的。
往栈里放入数据叫做压栈，从栈里出数据叫做出栈，我们用弹匣来举例，一个压满子弹的弹匣，第一个压入的子弹在弹匣的最底部，最后一个压人弹匣的子弹在最顶部，栈最先放入的数据所在的位置叫做栈底，栈最后放人的数据的位置叫做栈顶：
在这里插入图片描述
如图所示，栈底的元素是1，栈顶的元素是6
栈只支持在固定的一端插入和删除数据，进行删除和插入的一端叫做栈顶，另一端叫做栈底

栈的实现：

头文件 Stack.h：

#define _CRT_SECURE_NO_WARNINGS
#include<stdlib.h>
#include<stdio.h>
#include<stdbool.h>
#include<assert.h>


// 支持动态增长的栈
typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;		// 栈顶
	int capacity;  // 容量 
}Stack;

// 初始化栈 
void StackInit(Stack* ps);

// 入栈 
void StackPush(Stack* ps, STDataType data);

// 出栈 
void StackPop(Stack* ps);

// 获取栈顶元素 
STDataType StackTop(Stack* ps);

// 获取栈中有效元素个数 
int StackSize(Stack* ps);

// 检测栈是否为空，如果为空true，如果不为空返回false
bool StackEmpty(Stack* ps);

// 销毁栈 
void StackDestroy(Stack* ps);

函数的实现 Stack.c：
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include"Stack.h"

// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);
	//初始化为栈申请4个字节的空间
	STDataType* a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (a == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	ps->a = a;//数组
	ps->capacity = 4;//容量
	ps->top = 0;//栈顶下标

}

// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	//断言
	assert(ps);
	//判断容量是否够用
	if (ps->capacity == ps->top)
	{
		//不够扩容
		//扩容到之前容量的两倍
		STDataType* a = (STDataType*)realloc(ps->a,sizeof(STDataType) * (ps->capacity * 2));
		if (a == NULL)
		{
			perror("malloc");
			exit(-1);
		}
	}
	//使用栈顶top作为下标进行压栈
	ps->a[ps->top] = data;
	//将top++，作为下一次压栈的下标，同时也代表着现在栈里有多少个元素
	ps->top++;
}

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	//判断栈是否为空
	if (StackEmpty(ps))
	{
		printf("栈为空\n");
		exit(-1);
	}
	//将栈顶的元素移除
	//将top--，这样就访问不到栈顶的元素，而是将栈顶位置往下移了一个位置
	ps->top--;

}

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	//判断栈是否为空
	if (StackEmpty(ps))
	{
		printf("栈为空\n");
		exit(-1);
	}

	//top记录的是栈顶下一个位置
	//比如说top是0，当进行压栈的时候，0的位置压入数据变成栈顶
	//然后top++，为下一个入栈做准备
	//所以top--才是栈顶的元素
	//如果不想用--这个操作，初始化的时候将top初始化成-1即可
	return ps->a[ps->top - 1];
}

// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);
	//判断栈是否为空
	if (StackEmpty(ps))
	{
		printf("栈为空\n");
		exit(-1);
	}

	//这里也可以不用判断栈是否为空
	//当栈为空，top就是0，返回0也可以

	//top记录就是元素的个数
	return ps->top;
}

// 检测栈是否为空，如果为空true，如果不为空返回false
bool StackEmpty(Stack* ps)
{
	assert(ps);

	//初始化栈为空，记录栈顶个数的top也为空
	//每次入栈top++，每次出栈top--
	//所以当top为空时，栈就为空
	return ps->top == 0;
}

// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	//将栈释放
	free(ps->a);
	ps->a = NULL;

	//将容量和元素个数全部置为0
	ps->capacity = ps->top = 0;
}

主函数 test.c：

#define _CRT_SECURE_NO_WARNINGS
#include"Stack.h"


void mune()
{
	printf("********************************\n");
	printf("******1，压栈     2，出栈  *****\n");
	printf("******3，获取栈顶元素      *****\n");
	printf("******4，获取栈中有效元素的个数*\n");
	printf("******5，销毁栈            *****\n");
	printf("******6，判断栈是否为空    *****\n");
	printf("******0，退出（EXIT）      *****\n");
	printf("********************************\n");
}

int main()
{
	//创建栈并初始化
	Stack ST;
	StackInit(&ST);

	STDataType input = 0;
	do
	{
		//打印菜单
		mune();
		printf("请根据提示选择对应的功能：>");
		scanf("%d",&input);
		switch (input)
		{
		case 1:
			//压栈
			printf("输入要压栈的元素:>\n");
			STDataType i = 0;
			scanf("%d",&i);
			StackPush(&ST,i);
			printf("入栈成功,栈里有效元素%d个\n", StackSize(&ST));
			break;
		case 2:
			//出栈
			//获取栈顶元素
			printf("栈顶元素%d出栈成功\n", StackTop(&ST));
			//出栈
			StackPop(&ST);
			printf("栈里有效元素%d个\n", StackSize(&ST));
			break;
		case 3:
			//获取栈顶元素
			printf("栈顶元素为%d\n", StackTop(&ST));
			break;
		case 4:
			//获取栈里有效元素个数
			printf("栈里有效元素%d个\n", StackSize(&ST));
			break;
		case 5:
			//销毁栈
			StackDestroy(&ST);
			printf("栈销毁成功\n");
			break;
		case 6:
			//判断栈是否为空
			if (StackEmpty(&ST))
			{
				printf("栈为空,元素个数为%d\n", StackSize(&ST));
			}
			else
			{
				printf("栈不为空,元素个数为%d\n", StackSize(&ST));
			}
			break;
		case 0:
			printf("退出成功！！！\n");
			exit(-1);
			break;
		default:
			printf("选择错误，请重新选择:>\n");
			break;
		}
	} while (input);

	return 0;
}

队列

队列的概念和栈相反，先进先出，后进后出，比如说去排队左核酸，第一个排队的第一个做核酸，最后一个排队的最后最后做核酸，达到一个排队的效果。
队列是只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表
入队列：进行插入操作的一端称为队尾出队列：进行删除操作的一端称为队头
在这里插入图片描述
队列的插入删除，在实现上和链表的头插尾删非常相似

队列的实现：
在这里插入图片描述
创建一个结构体，结构体里放两个栈指针，初始化时将两个指针置为NULL,在第一次进行入队时，创建一个栈，将栈的第一个数据赋给两个指针，此后入队只需创建新节点然后和尾部指针相连，出队将头部指针销毁，然后将头部指针指向下一个节点，一直保持front指向队头，rear指向队尾

头文件声明 Queue.h：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>


typedef int QDataType;
// 链式结构：表示队列 
typedef struct QListNode
{
	QDataType data;//数据
	struct QListNode* next;//下一个节点
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* front;//队列头部
	QNode* rear;//队列尾部
	int size;//记录元素个数
}Queue;

// 初始化队列 
void QueueInit(Queue* q);

// 队尾入队列 
void QueuePush(Queue* q, QDataType data);

// 队头出队列 
void QueuePop(Queue* q);

// 获取队列头部元素 
QDataType QueueFront(Queue* q);

// 获取队列队尾元素 
QDataType QueueBack(Queue* q);

// 获取队列中有效元素个数 
int QueueSize(Queue* q);

// 检测队列是否为空，如果为空返回true，如果非空返回false 
bool QueueEmpty(Queue* q);

// 销毁队列 
void QueueDestroy(Queue* q);

函数的实现 Queue.c：

#define _CRT_SECURE_NO_WARNINGS
#include"Queue.h"


// 初始化队列 
void QueueInit(Queue* q)
{
	assert(q);
	//全部初始化为空
	q->front = NULL;
	q->rear = NULL;
	q->size = 0;
}

// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	//申请空间
	QNode* p = (QNode*)malloc(sizeof(QNode));
	if (p == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	//将值赋给p
	p->data = data;
	p->next = NULL;

	//第一次入队列
	if (q->front == NULL)
	{
		//第一次入队，两个指针同时指向栈底
		q->front = q->rear = p;
	}
	else
	{
		//将尾部的next和新节点连接
		q->rear->next = p;
		q->rear = p;
	}
	q->size++;
}

// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	//判断是否只有一个节点
	if (q->front == q->rear)
	{
		q->front = NULL;
		q->rear = NULL;
	}
	else
	{
		//保留头部
		QNode* p = q->front;
		q->front = q->front->next;
		//释放头部
		free(p);
	}
	q->size--;

}

// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	//判断队列是否为空
	if (QueueEmpty(q))
	{
		printf("队列为空\n");
		exit(-1);
	}

	//返回队头指针的数据
	return q->front->data;

}

// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	//判断队列是否为空
	if (QueueEmpty(q))
	{
		printf("队列为空\n");
		exit(-1);
	}

	//返回队尾指针的数据
	return q->rear->data;
}

// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	return q->size;
}

// 检测队列是否为空，如果为空返回true，如果非空返回false 
bool QueueEmpty(Queue* q)
{
	assert(q);
	//这里可以加上数据个数和尾部指针，也可以不加
	//保险一定可以都加上
	return q->front == NULL && q->rear == NULL && q->size == 0;
}

// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	while (q->front)
	{
		//保留上一个节点，再销毁下一个节点
		QNode* p = q->front;
		q->front = q->front->next;
		free(p);
	}
	q->size = 0;
	q->rear = NULL;
}

主函数 test.c：

#define _CRT_SECURE_NO_WARNINGS
#include"Queue.h"

void menu()
{
	printf("**************************************\n");
	printf("*****1，入队列       2，出队列    ****\n");
	printf("*****3，获取头部元素 4，获取尾部元素**\n");
	printf("*****5，获取有效元素个数          ****\n");
	printf("*****6，判断队列是否为空          ****\n");
	printf("*****7，销毁队列     0，退出      ****\n");
	printf("**************************************\n");
}

int main()
{
	//创建队列初始化
	Queue Q;
	QueueInit(&Q);

	int input = 0;
	QDataType i = 0;
	do
	{
		//打印菜单
		menu();
		printf("请输入序号进行操作：>");
		scanf("%d",&input);
		switch (input)
		{
			case 1:
				//入队列
				printf("请输入要入队的值:>\n");
				scanf("%d",&i);
				QueuePush(&Q,i);
				printf("%d入队成功，队列有效元素为%d\n",i, QueueSize(&Q));
				break;
			case 2:
				//出队列
				i = QueueFront(&Q);
				QueuePop(&Q);
				printf("队头元素%d出队列成功，队列有效元素为%d\n",i, QueueSize(&Q));
				break;
			case 3:
				//获取队头元素
				printf("队头元素为%d\n", QueueFront(&Q));
				break;
			case 4:
				//获取队尾元素
				printf("队尾元素为%d\n", QueueBack(&Q));
				break;
			case 5:
				//获取队列有效元素
				printf("队列有效元素为%d\n", QueueSize(&Q));
				break;
			case 6:
				//判断队列是否为空
				if (QueueEmpty(&Q))
				{
					printf("队列为空\n");
				}
				else
				{
					printf("队列不为空，元素个数为%d\n", QueueSize(&Q));
				}
				break;
			case 7:
				// 销毁队列 
				QueueDestroy(&Q);
				int j = QueueSize(&Q);
				if (QueueEmpty(&Q) == NULL && j == 0)
				{
					printf("队列销毁成功\n");
				}
				break;
			case 0:
				printf("退出成功！！！\n");
				return 0;
				break;
			default:
				printf("输入错误，请重新输入\n");
				break;
		}
	} while (input);
	return 0;
}

力扣笔试题

1，链接: 匹配括号
给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

只要是左括号就入栈，遇到右括号就将栈顶的左括号和右括号匹配
在这里插入图片描述

如果中途有一个不匹配直接return false
如果匹配上了，栈顶出元素，s++，进行下一个的匹配

typedef char STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;		// 栈顶
	int capacity;  // 容量 
}Stack;

// 检测栈是否为空，如果为空true，如果不为空返回false
bool StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;
}

// 初始化栈 
void StackInit(Stack* ps)
{
   //初始化为栈申请4个字节的空间
	STDataType* a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (a == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	ps->a = a;//数组
	ps->capacity = 4;//容量
	ps->top = 0;//栈顶下标
}

// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->capacity == ps->top)
	{
		STDataType* a = (STDataType*)realloc(ps->a,sizeof(STDataType) * (ps->capacity * 2));
		if (a == NULL)
		{
			perror("malloc");
			exit(-1);
		}
        ps->a = a;
        ps->capacity *= 2;
	}
	ps->a[ps->top] = data;
	ps->top++;
}

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	if (StackEmpty(ps))
	{
		printf("栈为空\n");
		exit(-1);
	}
	ps->top--;

}

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	if (StackEmpty(ps))
	{
		printf("栈为空\n");
		exit(-1);
	}
	return ps->a[ps->top - 1];
}

// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	//将栈释放
	free(ps->a);
	ps->a = NULL;

	//将容量和元素个数全部置为0
	ps->capacity = ps->top = 0;
}

bool isValid(char * s){
    //创建栈并初始化
    Stack ST;
    StackInit(&ST);
    while(*s)
    {
            //左括号入栈
            if(*s == '(' || *s == '{' || *s == '[')
            {
                //入栈
                StackPush(&ST,*s);
            }
            //否则就是遇到左括号，进行匹配
            else
            {
                //判断是否一直都是右括号，这样栈里就不会有元素
                //不会有元素就匹配不上
                if(StackEmpty(&ST))
                {
                    return false;
                }
                //保留栈顶元素
                char tmp = StackTop(&ST);
                //出栈
                StackPop(&ST);
                //是右括号就和栈顶元素匹配
                if((*s == '}' && tmp != '{')||
                    (*s == ')' && tmp != '(')||
                    (*s == ']' && tmp != '[')
                )
                {
                    //销毁栈
                    StackDestroy(&ST);
                    return false;
                }
            }
            //s++寻找下一个
            s++;
    }
    printf("结束\n");
    bool tf = StackEmpty(&ST);
    return tf;
}

这里强调一个特殊情况：
在这里插入图片描述

2，链接: 使用两个队列实现先进先出
在这里插入图片描述

typedef int QDataType;
// 链式结构：表示队列 
typedef struct QListNode
{
	QDataType data;//数据
	struct QListNode* next;//下一个节点
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* front;//队列头部
	QNode* rear;//队列尾部
	int size;//记录元素个数
}Queue;

// 初始化队列 
void QueueInit(Queue* q);

// 队尾入队列 
void QueuePush(Queue* q, QDataType data);

// 队头出队列 
void QueuePop(Queue* q);

// 获取队列头部元素 
QDataType QueueFront(Queue* q);

// 获取队列队尾元素 
QDataType QueueBack(Queue* q);

// 获取队列中有效元素个数 
int QueueSize(Queue* q);

// 检测队列是否为空，如果为空返回true，如果非空返回false 
bool QueueEmpty(Queue* q);

// 销毁队列 
void QueueDestroy(Queue* q);


// 初始化队列 
void QueueInit(Queue* q)
{
	assert(q);
	//全部初始化为空
	q->front = NULL;
	q->rear = NULL;
	q->size = 0;
}

// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	//申请空间
	QNode* p = (QNode*)malloc(sizeof(QNode));
	if (p == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	//将值赋给p
	p->data = data;
	p->next = NULL;

	//第一次入队列
	if (q->front == NULL)
	{
		//第一次入队，两个指针同时指向栈底
		q->front = q->rear = p;
	}
	else
	{
		//将尾部的next和新节点连接
		q->rear->next = p;
		q->rear = p;
	}
	q->size++;
}

// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	//判断是否只有一个节点
	if (q->front == q->rear)
	{
		q->front = NULL;
		q->rear = NULL;
	}
	else
	{
		//保留头部
		QNode* p = q->front;
		q->front = q->front->next;
		//释放头部
		free(p);
	}
	q->size--;

}

// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	//判断队列是否为空
	if (QueueEmpty(q))
	{
		printf("队列为空\n");
		exit(-1);
	}

	//返回队头指针的数据
	return q->front->data;

}

// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	//判断队列是否为空
	if (QueueEmpty(q))
	{
		printf("队列为空\n");
		exit(-1);
	}

	//返回队尾指针的数据
	return q->rear->data;
}

// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	return q->size;
}

// 检测队列是否为空，如果为空返回true，如果非空返回false 
bool QueueEmpty(Queue* q)
{
	assert(q);
	//这里可以加上数据个数和尾部指针，也可以不加
	//保险一定可以都加上
	return q->front == NULL && q->rear == NULL && q->size == 0;
}

// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	while (q->front)
	{
		//保留上一个节点，再销毁下一个节点
		QNode* p = q->front;
		q->front = q->front->next;
		free(p);
	}
	q->size = 0;
	q->rear = NULL;
}


typedef struct {
    Queue pus;
    Queue pop;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    //初始化队列
    QueueInit(&obj->pus);
    QueueInit(&obj->pop);
    return obj;
}

//入队
void myQueuePush(MyQueue* obj, int x) {
    //入队只往pus中入
    QueuePush(&obj->pus,x);
}

//返回队头元素
int myQueuePeek(MyQueue* obj) {
    //如果pop中有数据，将pop队头数据返回即可
    //如果pop中没有数据
    if(QueueEmpty(&obj->pop))
    {
        //将pus中的数据全部导入pop
        while(!QueueEmpty(&obj->pus))
        {
            //导入
            QueuePush(&obj->pop,QueueFront(&obj->pus));
            //删除pus头数据
            QueuePop(&obj->pus);
        }
    }
    //返回pop队头数据
    return QueueFront(&obj->pop);
}

//移除队头并返回
int myQueuePop(MyQueue* obj) {
    //先调用peek函数，来确保pop中有数据
    int i = myQueuePeek(obj);//保留队头数据
    QueuePop(&obj->pop);//让队头出队列
    return i;
}



//判断队列是否为空
bool myQueueEmpty(MyQueue* obj) {

    //如果两条队列都为空返回true
    return QueueEmpty(&obj->pus) && QueueEmpty(&obj->pop);
}

//销毁队列
void myQueueFree(MyQueue* obj) {
    QueueDestroy(&obj->pus);
    QueueDestroy(&obj->pop);
    free(obj);
    obj = NULL;

}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

3，链接: 循环队列
在这里插入图片描述

typedef struct {
    int* a;//数组
    int frond;//头
    int rear;//尾
    int k;//数组大小
} MyCircularQueue;

//创建并初始化
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int) * (k+1));//多开一个空间
    obj->frond = 0;
    obj->rear = 0;
    obj->k = k;
    return obj;
}
//检查队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    //当两个下标相同时为空
    return obj->frond == obj->rear;
}
//检查队列是否已满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    //第一种情况，rear在最后一个位置，frond在0的位置
    if(obj->rear == obj->k && obj->frond == 0)
    {
        return true;
    }
    //第二种情况，rear+1等于frond
    else if(obj->rear+1 == obj->frond)
    {
        return true;
    }
    return false;
    // return (obj->rear+1) % (obj->k+1) == obj->frond;
}
//插入元素，成功返回true
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    //判断是否为满
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    //先将数据放在rear的位置
    obj->a[obj->rear] = value;
    //当rear在最后的位置，让rear回到0的位置
    if(obj->rear == obj->k)
    {
        obj->rear = 0;
        return true;
    }
    //rear向后挑一部
    obj->rear++;
    return true;
}
//删除元素，成功返回true
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    //判读是否为空
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    //frond在最后的位置，+1让reond回到0
    if(obj->frond == obj->k)
    {
        obj->frond = 0;
        return true;
    }
    obj->frond++;
    return true;

}
//获取队头元素，如果队列为空返回-1
int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->a[obj->frond];
}
//获取队尾元素，队列为空返回-1
int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    //rear记录的是下一次插入元素的位置
    //所以上一次插入元素的位置是rear-1
    if(obj->rear == 0)
    {
        return obj->a[obj->k];
    }
    return obj->a[obj->rear-1];
}
//销毁队列
void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/