【数据结构】队列的顺序表实现&&收尾栈和队列

已于 2022-09-12 16:49:44 修改
阅读量543 收藏 9
点赞数 22
分类专栏： 数据结构 文章标签： 数据结构
于 2022-08-10 19:49:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NEFUT/article/details/126273134
版权

在这里插入图片描述每一个不曾起舞的日子，都是对生命的辜负。

队列的顺序表实现&&收尾栈和队列

1. 队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头。

  • 队列与栈的区别是出的顺序恰好相反

在这里插入图片描述

2. 队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，需要将后面的元素覆盖到前面，复杂度为O(N)，效率会比较低。

在这里插入图片描述

结构体的封装：

typedef int QDataType;
typedef struct QueueNode//定义节点
{
    QDataType data;
    struct QueueNode* next;
}QNode;

typedef struct Queue//通过定义此结构体记录队列的头、尾、大小
{
    QNode* head;
    QNode* tail;
    int size;
}Queue;

Queue.h

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


typedef int QDataType;
typedef struct QueueNode
{
	QDataType* data;
	struct Queue* next;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

void QueueInit(Queue* pq);// 初始化队列
void QueueDestory(Queue* pq);// 销毁队列
void QueuePush(Queue* pq,QDataType x);// 队尾入队列
void QueuePop(Queue* pq);// 队头出队列
QDataType QueueFront(Queue* pq);// 获取队列头部元素
QDataType QueueBack(Queue* pq);// 获取队列队尾元素
bool QueueEmpty(Queue* pq);// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueSize(Queue* pq);// 获取队列中有效元素个数

Queue.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"


void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
void QueueDestory(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 = pq->tail->next;
	}
	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);
	}
	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;
}

Test.c

#define _CRT_SECURE_NO_WARNINGS 1
#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, 5);
	QueuePush(&q, 6);
	printf("\n");
	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}printf("\n");

}
int main()
{
	TestQueue();
	return 0;
}

在这里插入图片描述

3. 栈和队列LeetCode.oj

由于此语言为C语言，因此我们在实现oj之前需要将之前的代码复制进去，否则没有对应封装好的函数

1. 有效的括号

20. 有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。

示例 1：

输入：s = "()"
输出：true

示例 2：

输入：s = "()[]{}"
输出：true

示例 3：

输入：s = "(]"
输出：false

示例 4：

输入：s = "([)]"
输出：false

示例 5：

输入：s = "{[]}"
输出：true

提示：

  • 1 <= s.length <= 104
  • s 仅由括号 '()[]{}' 组成

思路：这是一道利用栈解决的问题，即下一个进来的如果是左括号则储存，是右括号则看与栈顶的元素是否匹配，若匹配，栈顶元素弹出，继续执行，若不匹配，则返回false。需要注意的是，若所有的元素都分配完毕，此时栈仍不为空，这说明不匹配，返回false.

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

void StackInit(ST* ps);
void StackDestory(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)
{
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}


void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
		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);
    while(*s)
    {
        if(*s == '('||*s == '['||*s=='{')
        {
            StackPush(&st,*s);
        }
        else
        {
            if(StackEmpty(&st))
              return false;
            STDataType obj = StackTop(&st);
            
            if((obj == '{' && *s == '}')||
               (obj == '[' && *s == ']')||
               (obj == '(' && *s == ')'))
            {
                StackPop(&st);
            }
            else
            {
                
                return false;
            }

        }
        s++;
    }
    if(st.top!=0)
      return false;
   return true;

}

2.用队列实现栈

225. 用队列实现栈

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

  • void push(int x) 将元素 x 压入栈顶。
  • int pop() 移除并返回栈顶元素。
  • int top() 返回栈顶元素。
  • boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

  • 你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
  • 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

提示：

  • 1 <= x <= 9
  • 最多调用100 次 push、pop、top 和 empty
  • 每次调用 pop 和 top 都保证栈不为空

**进阶：**你能否仅用一个队列来实现栈。

思路：很明显的是，栈的特点是先进后出，队列的特点是先进先出，那么如何用先进先出的队列实现先进后出的栈呢？这就不仅仅依靠一个队列了，而是两个队列元素之间的相互转换，如：q1 : 1 、2、3、4、5

q2:NULL;那么如何将其Top时变成5、4、3、2、1？

这就需要画图去思考：

在这里插入图片描述

按正常逻辑，对于队列应该是1->2->3->4->5的顺序弹出队列，但要其相反，我们就要：将q1的前4个元素移到q2,再弹出q1的时候就是最后进的元素了。

在这里插入图片描述

于是这个步骤就可以反复执行，直到两个队列均变成空。

代码实现：

typedef int QDataType;
typedef struct QueueNode
{
    QDataType* data;
    struct Queue* next;
}QNode;

typedef struct Queue
{
    QNode* head;
    QNode* tail;
    int size;
}Queue;

void QueueInit(Queue* pq);// 初始化队列
void QueueDestory(Queue* pq);// 销毁队列
void QueuePush(Queue* pq,QDataType x);// 队尾入队列
void QueuePop(Queue* pq);// 队头出队列
QDataType QueueFront(Queue* pq);// 获取队列头部元素
QDataType QueueBack(Queue* pq);// 获取队列队尾元素
bool QueueEmpty(Queue* pq);// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueSize(Queue* pq);// 获取队列中有效元素个数



void QueueInit(Queue* pq)
{
    assert(pq);
    pq->head = pq->tail = NULL;
    pq->size = 0;
}
void QueueDestory(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 = pq->tail->next;
    }
    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);
    }
    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;
}


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) {
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) {
    Queue* empty = &obj->q1;
    Queue* nonempty = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        nonempty = &obj->q1;
        empty = &obj->q2;
    }

    while(QueueSize(nonempty)>1)
    {
        QueuePush(empty,QueueFront(nonempty));
        QueuePop(nonempty);
    }
    int top = QueueFront(nonempty);
    QueuePop(nonempty);
    return top;

}

int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&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) {
    QueueDestory(&obj->q1);
    QueueDestory(&obj->q2);
    free(obj);
}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);

 * int param_2 = myStackPop(obj);

 * int param_3 = myStackTop(obj);

 * bool param_4 = myStackEmpty(obj);

 * myStackFree(obj);
*/

3. 用栈实现队列

232. 用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

  • void push(int x) 将元素 x 推到队列的末尾
  • int pop() 从队列的开头移除并返回元素
  • int peek() 返回队列开头的元素
  • boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明：

  • 你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
  • 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例 1：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

提示：

  • 1 <= x <= 9
  • 最多调用 100 次 push、pop、peek 和 empty
  • 假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）

进阶：

  • 你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。

思路：对于这道题，思想与上道题一样，只是变化了对象，用两个先进后出实现先进先出，但值得注意的是， 由于栈先进后出的特点，经过调换，没必要像上道题一样来回反复移动，而是定义一个专门用来push的，另一个专门用来Top的：

在这里插入图片描述

输出的时候将pushST的全部导入popST：

在这里插入图片描述

这样就可以实现队列的先进先出的原则。

代码：

typedef int STDataType;
typedef struct Stack
{
    STDataType* a;
    int top;
    int capacity;
}ST;

void StackInit(ST* ps);//ʼ
void StackDestory(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)
{
    ps->a = NULL;
    ps->top = ps->capacity = 0;
}


void StackDestory(ST* ps)
{
    assert(ps);
    free(ps->a);
    ps->a = NULL;
    ps->top = ps->capacity = 0;
}
void StackPush(ST* ps, STDataType x)
{
    if (ps->top == ps->capacity)
    {
        int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
        STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
        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) {
    StackPush(&obj->pushST,x);
}

int myQueuePop(MyQueue* obj) {
    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }

    int front = StackTop(&obj->popST);
    StackPop(&obj->popST);
    return front;
}

int myQueuePeek(MyQueue* obj) {
    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    return StackTop(&obj->popST);
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->pushST)&&StackEmpty(&obj->popST);
}

void myQueueFree(MyQueue* obj) {
    StackDestory(&obj->pushST);
    StackDestory(&obj->popST);
    free(obj);
}

/**
 * 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);
*/

4.设计循环队列

622. 设计循环队列

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

  • MyCircularQueue(k): 构造器，设置队列长度为 k 。
  • Front: 从队首获取元素。如果队列为空，返回 -1 。
  • Rear: 获取队尾元素。如果队列为空，返回 -1 。
  • enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
  • deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
  • isEmpty(): 检查循环队列是否为空。
  • isFull(): 检查循环队列是否已满。

示例：

MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
circularQueue.enQueue(1);  // 返回 true
circularQueue.enQueue(2);  // 返回 true
circularQueue.enQueue(3);  // 返回 true
circularQueue.enQueue(4);  // 返回 false，队列已满
circularQueue.Rear();  // 返回 3
circularQueue.isFull();  // 返回 true
circularQueue.deQueue();  // 返回 true
circularQueue.enQueue(4);  // 返回 true
circularQueue.Rear();  // 返回 4

提示：

  • 所有的值都在 0 至 1000 的范围内；
  • 操作数将在 1 至 1000 的范围内；
  • 请不要使用内置的队列库。

对于此题，是队列，但是并不像前几道题一样，需要我们将之前的函数代码放到里面，而是需要自己去实现。上述已经说过，队列既可以由链表实现，也可以由数组实现，而在上述中的创建空间的接口中用的是链表实现，对于此题，如果用链表实现的话，则需要不断地开辟新节点来构造此空间，而用数组一步malloc就可以创建，相比较，前者较为麻烦，因此，在这里，我们采用数组。

既然是循环数组，我们有两种方式判断其是否满或者空，一是创建时用一个size来记录数量，二是利用循环的特性，设置两个下标，head代表头，tail代表尾，为了凸显循环的特性，我们采用后者。那么，如何利用这两个下标指针判断其是否为空为满呢？

这时大概率会想到：当head与tail重合的时候，是否就可以看成满了呢？好，那顺着这个来，当我们定义head=tail=0的时候，内部没有元素，head与tail都在起始位置，即head = tail = 0,然而此时却是空，这代表着我们之前构建的大思路错误了吗？当然不是，大家也会猜到，如果都是错误的，何必这么大费周章呢？既然大思路没错，我们就想一想如何改善这个判断空和满的条件，这里也就不卖关子了，可以进行如下改善：让malloc出来的空间比需要的空间多一个，但这最后一个并不存储数据，恰恰作为一个条件，当尾指针走到这里，就说明满，当尾指针与头指针重合就可以代表空 ，但是利用数组的话，如何让其尾指针走到头的位置呢？这里采用的是取模，即tail%N。

举个例子：当我们需要构建四个空间放置元素，此时我们应多开辟一个空间即N = 5

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

此时，数组的空间已满,由于head和tail都是数组下标，默认从0开始，而tail到图中的位置时tail恰好等于4，可以看出，当（tail+1)%N == head时，就代表满。

接下来看看如何判空：

在这里插入图片描述

由于是循环队列，每次tail改变我们都需要让tail = tail%N，目的是让其的指向可以循环，通过上图可以看出head == tail时即可判空，（或者tail%N == head%N)。

那么，最关键的接口我们的逻辑已经推演完成，接下来看看代码吧！(注：这里的头和尾分别用的是front和back)

typedef struct {
    int* a;
    int front;
    int back;
    int N;

} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int)*(k+1));
    obj->front = obj->back = 0;
    obj->N = k+1;

    return obj;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->back == obj->front;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->back+1) % obj->N == obj->front;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    return false;

    obj->a[obj->back] = value;
    obj->back++;
    obj->back %= obj->N;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return false;

    obj->front++;
    obj->front %=obj->N;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return -1;

    return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return -1;

    return obj->a[(obj->back-1+obj->N)%obj->N];
}




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);
*/

4. 总结

到这里，栈和队列的讲解基本上就完成了，但这里由于我们用的C语言实现，接口都需要自己提供，因此只是让大家了解以及能够面对一些oj题，更加复杂的内容将会在C++里一并实现。

每天都要进步呀~
关注
专栏目录
基础数据结构：循环队列
weixin_58368590的博客
02-21 334
先写头文件list.h #pragma once #define MAX_SIZE 100 //循环队列结构体设计： typedef int ELEM_TYPE; typedef struct Queue { ELEM_TYPE *base; //这个指针用来接收malloc从堆里申请的数组 int front;//队头指针（实际上保存的是数组下标，int） int rear;//队尾指针 （实际上保存的是数组下标，int） }Queue, *PQueue; //增删改查 //初始化 ...
Python数据结构与算法笔记（七）：数据结构——队列，链表和哈希表
AvenueCyy的博客
08-03 524
队列 链表
队列简单实现
boyhailong的专栏
01-13 1187
之前用习惯了面向对象的调用方式，用C写过程的还是有点不习惯，不过管用就行。 队列的操作很简单： 1、先进先出 2、入队的时候要检测队列是否已满； 3、出队列的时候要检测是否为空； #include #include #include "stdio.h" #include "malloc.h" typedef int ElementType; #define CheckNULLQue
顺序表实现队列
qq_41027326的博客
04-08 438
一. 队列相关概念      队列是只允许在一段进行插入元素, 在另一端进行删除元素的线性表,即只允许对队列进行尾插,头删的操作.队列具有先进先出, 后进后出的特性.              1.初始化 void SeqQueInit(SeqQue* q) { if(q == NULL) { return;//非法输入 } q -&gt...
利用顺序表实现的顺序队列
lzjsqn的专栏
05-10 587
这个实际上就是顺序表，只不过zai
基于顺序表实现队列
Cecilia3333的博客
04-10 348
队列是一种先进先出（FIFO）的特殊线性表。它只允许在表的一端进行插入，而在另一端删除元素。在队列中，允许插入的一端叫做队尾，允许删除的一端则称为队头。队列的基本操作也有三种，分别为：入队列、出队列、取队首元素。seqqueue.h： #pragma once #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;stddef...
《大话数据结构》队列的顺序存储和链式存储
知的IT成长之路
12-12 1381
1. 简介 成都的火车南站早上真的恐怖，地铁站人山人海，从地铁里面一直排队到门口，虽然人很多但是不得不说我国人民素质还是蛮高的，都是来了之后排在队伍的最后面，没有一个人去插队。这样不仅避免了人员拥挤的混乱，也让需要乘坐地铁的人可以尽快乘上地铁。 其实我们的队列就像排队等地铁一样，遵从先来后到，先来的人先上车后来的人后上车，队列则是先插入的数据，先取出去，后来的数据后取出去，先进先...
【数据结构】链表(含链式前向星)
Xm_wy的博客
09-05 196
  链表为什么断不了？是拿振金做的吗？   说了队列，说了栈，无论什么数据结构都离不开只能按一定顺序储存的结果，向特定位置加入某值的复杂度达不到O(1)O(1)O(1)。天空一声巨响，链表闪亮登场 链表就是这千千万万数据结构中的一个例外。   链表的模型就是一条链！我们可以向这条链的任意一个地方加入一个新的节点，也可以删除任意的一个节点。 ...
嵌入式C语言入门——队列（顺序队列）
qq_35599308的博客
12-12 579
数据结构之队列顺序队列构造顺序队列顺序队列的初始化判断队列是否满判断队列是否为空顺序队列的入队顺序队列的出队顺序队列的读取 顺序队列 存放数据的队列数组当做收尾相接的表处理(对长度进行SIZE取余作为数组下标) 若定义队列数组长度为SIZE,能存放数据的只有SIZE-1个元素 队头,队尾指针从前进时从SIZE-1,直接进到0 队列满时,若rear向前进一步则会与front相遇 队头指针向前一...
数据结构易错100题
ycy的博客
10-01 2445
链表的物理存储结构具有同链表一样的顺序（）。 答案：正确。 物理存储结构不连续。 已知某二叉树的前序为（1-2-3-4-5-6-7-8-9），中序为（2-3-1-6-7-8-5-9-4），则它的后续为？ 答案：3-2-8-7-6-9-5-4-1。 设栈最大长度为 3 ，入栈序列为 1 ， 2 ， 3 ， 4 ， 5 ， 6 ，则不可能得出栈序列是（） A.1 ， 2 ， 3 ， 4 ， 5 ， 6 B.2 ， 1 ， 3 ， 4 ， 5 ， 6 C.3 ， 4 ， 2 ， 1 ， 5 ， 6 ..
链表，顺序表，队列，栈的实现
09-19
这里有顺序变，链表，栈，队列的实现的完整程序，程序附加有大量说明，链表中还包含循环链表，双向链表，同时又串，图的程序。
数据结构-基于顺序表实现顺序队列
mxrrr_sunshine的博客
04-08 709
首先了解队列这种结构： 只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表 进行插入操作的一端称为队尾（入队列） 进行删除操作的一端称为对头（出队列） 队列具有先进先出的的特性 基于顺序表实现的队列有以下操作： 初始化队列 入队列 出队列 取队首元素 销毁队列 定义结构定义了一个最大长度为100的队列，一个size用来记录当前顺序队列的大小，一个head一个ta
C/C++语言实现数据结构系列（五）——顺序表实现队列
索半斤的博客
08-06 129
#include<stdio.h> #define MAXSIZE 8 #define ERROR 0 #define Status int #define SUCESS 1 typedef struct Node{ int front,rear; int data[MAXSIZE]; }*Queue; void InitQueue(Queue &queue){ queue->front = 0; queue->rear = 0; } Status isEmp
数据结构— —队列(顺序表实现)
m0_65635427的博客
11-04 2189
数据结构队列顺序实现
顺序表-队列
月光酒馆
10-14 223
//循环队列的基本操作 #include&lt;stdio.h&gt; #define MaxSize 50 typedef int ElemType; //定义循环队列结构体 typedef struct { ElemType data[MaxSize]; int front,rear; }SqQueue; //初始化 void InitQueue(SqQueue &amp;Q) { Q...
数据结构—顺序表，链表实现队列
Acer12138的博客
11-04 277
顺序表实现队列 #include &amp;lt;cstdio&amp;gt; #include &amp;lt;cstring&amp;gt; #include &amp;lt;iostream&amp;gt; #include &amp;lt;algorithm&amp;gt; using namespace std; #define maxsize 110 #define OK 1 #define ERROR 0 #define OV
数据结构-顺序表实现队列的基本操作
zgege的博客
04-19 997
队列的定义 队列是另一种限定的数据结构，它只允许在表的一端插入，另一端删除。所以队列具有先进先出的特性。这与我们生活中的排队是一个道理。 在队列中允许删除的一端叫做队头，允许插入的一端叫做队尾。 队列分类 顺序队列（容易引起假溢出情况：顺序队列因多次入队，出队后出现的尚有存储空间，但不能在进行如队列的操作） 优先级队列 循环队列 本文用顺序表实现队列的基本操作 初始化 操作前提...
数据结构与算法 队列(顺序表实现)
T
11-09 542
数据结构与算法 队列 简单描述：队列是一种受限制的线性结构(先进先出)，它只能在表的前端进行删除，在表的后端进行插入。 一、用顺序表实现 1.初始化队列，判断队列是否为空，是否为满 宏定义设置这个队列的最大容量，重新定义类据类型作为队列的数据类型，这样可方便修改，结构体队列中除数据区外，还定义了两个整型变量front、rear，分别用来表示该队列的首部位置和尾部位置（当前队列最后已有元素位置的下一...
数据结构—队列的实现（顺序表）
luhaowei0066的博客
04-11 430
数据结构中的队列有“先进先出”的特点，意思是最先被存进队列中的数据，总是最先被取走一个队列只有初始化，销毁，入队列，出队列和取队首元素，这些限制往往使在操作数据时更安全，代码容易实现，出现BUG的机会就很少上图队列，如过进行了多次入队列和出队列，就会是head之前的空间浪费，如下图为了避免这种浪费空间的测操作，当每次head 和 tail 只要到达最后一个元素，操作完成就让他们回到对列的最前面，即...
C++实现顺序队列：数据结构与顺序栈详解
"该资源介绍了如何使用C++语言定义顺序队列，并且详细阐述了栈的概念，...该资源提供了一个简单的C++实现顺序栈的实例，通过理解这个实例，读者可以掌握栈的基本概念和操作，为进一步学习其他数据结构和算法打下基础。
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

每天都要进步呀~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值