＜数据结构＞刷题笔记——栈和队列篇（动图详解）

已于 2022-04-10 09:03:49 修改
阅读量2k 收藏 46
点赞数 99
分类专栏： 刷题 数据结构（c语言实现） 文章标签： c语言 数据结构
于 2022-04-09 22:26:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47882731/article/details/124069573
版权

文章目录

目前在不断更新<数据结构>的知识总结，已经更新完了<C语言>，未来我会系统地更新<C++语言><Linux系统编程><Linux网络编程><MySQL数据库>等内容。

本系列相关文章：
＜数据结构＞你分得清栈和队列吗？
已完结系列文章总结：
c语言自学教程——博文总结
我的gitee，欢迎来看看：gitee网址
想要一步步稳扎稳打，学习编程的小伙伴可以关注我，文章都是免费的，不错过这一个提升自己的机会！

1. 有效的括号

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

有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

示例 1：
输入：s = “()”
输出：true

示例 2：
输入：s = “()[]{}”
输出：true

示例 3：
输入：s = “(]”
输出：false

示例 4：
输入：s = “([)]”
输出：false

示例 5:
输入：s = “{[]}”
输出：true

提示：
1 <= s.length <= 104
s 仅由括号 ‘()[]{}’ 组成

【链接】

20. 有效的括号

【思路】

数括号能不能数出来呢？不行，"([)]"的数量符合要求但括号的种类不匹配。
让我们换一种思路，运用我们学到的栈。遇到左括号就入栈，遇到右括号就出栈，栈是后进先出的，出栈出的是最近入进去的括号，如果都可以匹配上，就返回“true”，否则返回“false”。
请添加图片描述

思路就这捋顺了，接下来就要写代码了。但问题来了，从哪能搞来栈用呢？因为我们还没学到C++在这就只能憋屈得自己写个栈了，我上一篇文章＜数据结构＞你分得清栈和队列吗？写的栈直接复制过来用，这就是为什么参考代码那么长，其实新东西只有最后那一点。

在此强调一下，一定要保证栈的代码正确再使用，否则会bug重重，很难改。

【参考代码】

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


void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//满了扩容
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		ps->a = (STDataType*)realloc(ps->a, newCapacity*sizeof(STDataType));
		if (ps->a == NULL)
		{
			printf("realloc fail");
			exit(-1);
		}
		ps->capacity = newCapacity;
	}

	ps->a[ps->top] = x;
	ps->top++;
}

void StackPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
}

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);
            s++;
        }
        else
        {
            if(StackEmpty(&st))//防越界
                return false;

            char top = StackTop(&st);
            StackPop(&st);
            if((*s == '}' && top != '{')
            ||(*s == ']' && top != '[')
            ||(*s == ')' && top != '('))
            {
                StackDestory(&st);
                return false;
            }
            s++;
        }
    }
    bool ret = StackEmpty(&st);
    StackDestory(&st);

    return ret;

}

2. 用队列实现栈

请你仅使用两个队列实现一个后入先出（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 都保证栈不为空

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

【链接】

225. 用队列实现栈

【思路】

用两个队列实现一个栈。两者的最大不同就是队列是先进先出的，栈是后进先出的。
实现入栈就随便把数据放到一个队列里
想要实现出栈，得先把挡在前面的数据放到另一个队列中，最后才能出栈
如果后续还要实现入栈就入到仍有数据的队列中
这是一个典型的接口型OJ题，你需要完善里面的函数。
队列和上一题一样，目前只能用自己写的复制到代码中

请添加图片描述

【参考代码】

typedef int QDataType;

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

//找到头和尾
typedef struct Queue
{
	QNode* head;
	QNode* tail;
}Queue;

void QueueInit(Queue* pq); 
void QueueDestory(Queue* pq); 
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
bool QueueEmpty(Queue* pq);
size_t QueueSize(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);


void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}

void QueueDestory(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	assert(newnode);
	newnode->data = x;
	newnode->next = NULL;

	if (pq->tail == NULL)
	{
		assert(pq->head == NULL);
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head && pq->tail);
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}

size_t QueueSize(Queue* pq)
{
	assert(pq);
	size_t size = 0;
	QNode* cur = pq->head;
	while (cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->tail);
	return pq->tail->data;
}

typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    assert(pst);
    QueueInit(&pst->q1);
    QueueInit(&pst->q2);
    return pst;
}

void myStackPush(MyStack* obj, int x) {
    assert(obj);
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1, x);
    }
    else
    {
        QueuePush(&obj->q2, x);
    }
}

int myStackPop(MyStack* obj) {
    assert(obj);
    Queue* emptyQ = &obj->q1;
    Queue* nonEmptyQ = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        emptyQ = &obj->q2;
        nonEmptyQ = &obj->q1;
    }
    //把非空队列的前N个数据，导入空队列，只剩最后一个删掉
    //就实现了后进先出
    while(QueueSize(nonEmptyQ)>1)
    {
        QueuePush(emptyQ, QueueFront(nonEmptyQ));
        QueuePop(nonEmptyQ);
    }
    int top = QueueFront(nonEmptyQ);
    QueuePop(nonEmptyQ);//记得pop掉
    return top;
}

int myStackTop(MyStack* obj) {
    assert(obj);
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
    assert(obj);
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    assert(obj);
    QueueDestory(&obj->q1);
    QueueDestory(&obj->q2);
    free(obj);
    obj = NULL;
}

3. 用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（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) ，即使其中一个操作可能花费较长时间。

【链接】

232. 用栈实现队列

【思路】

这跟上一题是姐妹题
但有些不同，因为从一个栈到另一个栈，内容的顺序会颠倒过来，这次我们规定一个固定的实行入队列的栈，和一个固定的出队列的栈。

后续请看动图
请添加图片描述

【参考代码】

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

void StackInit(ST* ps);//初始化
void StackDestory(ST* ps);//销毁
void StackPush(ST* ps, STDataType x);//入栈
void StackPop(ST* ps);//出栈
bool StackEmpty(ST* ps);//判断栈是否为空
STDataType StackTop(ST* ps);//返回栈顶元素
int StackSize(ST* ps);//栈里的元素个数



void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//满了扩容
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		ps->a = (STDataType*)realloc(ps->a, newCapacity*sizeof(STDataType));
		if (ps->a == NULL)
		{
			printf("realloc fail");
			exit(-1);
		}
		ps->capacity = newCapacity;
	}

	ps->a[ps->top] = x;
	ps->top++;
}

void StackPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
}

int StackSize(ST* ps)//元素个数
{
	assert(ps);
	return ps->top;
}

typedef struct {
    ST pushST;
    ST popST;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* pst = (MyQueue*)malloc(sizeof(MyQueue));
    assert(pst);
    StackInit(&pst->pushST);
    StackInit(&pst->popST);
    return pst;
}

void myQueuePush(MyQueue* obj, int x) {
    assert(obj);
    StackPush(&obj->pushST,x);
}

int myQueuePop(MyQueue* obj) {
    assert(obj);
    //空了再加进去
    if(StackEmpty(&obj->popST))
    {
        while(StackSize(&obj->pushST))
        {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    
    int head = StackTop(&obj->popST);
    StackPop(&obj->popST);

    return head;
}

int myQueuePeek(MyQueue* obj) {
     assert(obj);
    //空了再加进去
    if(StackEmpty(&obj->popST))
    {
        while(StackSize(&obj->pushST))
        {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    
    int head = StackTop(&obj->popST);

    return head;
}

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

void myQueueFree(MyQueue* obj) {
    assert(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. 设计循环队列

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 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 的范围内；
请不要使用内置的队列库。

【链接】

622. 设计循环队列

【思路】

为了能用head和tail判断队列是满还是空，我们想要存放n个数据得开辟n+1个空间。
这样的话front=tail时是空，tail+1=front时（不越界的情况）是满，能够区别开
这题用顺序表或链表都能实现，我为了更方便的找到尾元素就打算用顺序表（数组）实现一下，这个的要小心到了数组尾部要回到头部再走

请添加图片描述

【参考代码】

typedef struct {
    int* a;
    int front;
    int tail;
    int k;
} MyCircularQueue;

bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

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

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

    obj->a[obj->tail] = value;
    if(obj->tail == obj->k)
    {
        obj->tail = 0;
    }
    else
    {
        obj->tail++;
    }
    return true;

}

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

    if(obj->front == obj->k)
    {
        obj->front = 0;
    }
    else
    {
        obj->front++;
    }
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    assert(obj);
    if(!myCircularQueueIsEmpty(obj))
    {
        return obj->a[obj->front];
    }
    else
    {
        return -1;
    }
}

int myCircularQueueRear(MyCircularQueue* obj) {
    assert(obj);
    if(!myCircularQueueIsEmpty(obj))
    {
        if(obj->tail == 0)
        {
            return obj->a[obj->k];
        }
        else
        {
            return obj->a[obj->tail-1];
        }
    }
    else
    {
        return -1;
    }
}

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

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    assert(obj);
    if(obj->tail == obj->k)
    {
        return obj->front == 0;
    }
    else
    {
        return obj->front == obj->tail+1;
    }
}

void myCircularQueueFree(MyCircularQueue* obj) {
    assert(obj);
    free(obj->a);
    free(obj);
    obj = NULL;
}

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

动图花了我很多心思，希望对大家有所帮助。☀️
由于本人实力有限，如果文中出现错误❌请提出来。
如果觉得有所收获，还请点个赞❤️鼓励一下博主。😉
还不太懂的朋友也不要失落😔，先收藏起来，等到合适的时机再看一看，也许能够恍然大悟🌈，有所得。
<数据结构>系列还在不断更新，关注我，跟我一起一步一步学习数据结构把！😄

天影云光
关注
  • 99
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 160
    评论
专栏目录
数据结构和算法-Flash动画演示
02-03
该资源使用flash动画来演示相关算法的运算过程，内容包括查找、排序、链表、栈与队列，树、图等等。演示时，可以输入数字，如果别的播放器不好使，可以使用qq播放器。
数据结构与算法——堆和堆排序 动画演示
l0919160205的博客
02-03 4344
普通队列：先进先出，后进后出 优先队列：出队顺序和入队顺序无关，和优先级有关 例如：在N个元素中选择前M个元素，用排序的方法复杂度为NlogN,而使用堆则为NlogM ...
数据结构——循环队列（GIF图解）
weixin_43294413的博客
12-17 3645
一、循环队列 数组队列的出队操作的复杂度是O(n)，性能很差，解决方法就是使用循环队列（Loop Queue） 在循环队列中，需要对队为空和队为满的时候进行判断，为了区分队空和队满两个条件，需要浪费capacity一个空间，让rear指针一直指向一个空的位置； 当 rear= =front 时，队为空； 当 (rear+1)%n= =front (n为数字角标的最大值)时，队为满. 示意图如下...
c语言模拟实现队列(动图演示）
sea18323的博客
12-17 358
队列是限制结点插入操作固定在一端（队尾rear）进行,而结点的删除操作固定在另一端(队首front)进行的线性表.特点是：先进先出，后进后出。由定义可知，队列同栈一样，都可分成俩种存储结构：顺序结构存储,链式结构存储。之前栈的实现我们是用顺序表来实现的，那么这个我们就用链表来实现。下面我们先以很像队列的一个生活实例：银行办理业务：动图演示：数据{4，7，8，9}分别插入队列由上图可知我们的链表元素中要包含什么1.头尾指针2.数据3.指向下一个节点的指针。
【玩转栈和队列①】栈的C语言实现（动图演绎）
罅隙的博客
04-05 962
良心制作，动图演绎。重点突破栈接口的C语言实现
数据结构第三章笔记——栈和队列
10-21
数据结构第三章笔记——栈和队列
《Java数据结构和算法》学习笔记(3)——栈和队列
03-14
本文将基于《Java数据结构和算法》学习笔记中的“栈和队列”部分进行深入探讨。 栈（Stack）是一种线性数据结构，遵循后进先出（LIFO, Last In First Out）的原则。在栈中，元素的添加（压栈）和移除（弹栈）都是在...
严蔚敏<<数据结构>>课堂笔记 1.71MB
07-12
4. 栈和队列：两种特殊的数据结构，分别具有后进先出（LIFO）和先进先出（FIFO）的特性。 5. 串：字符串处理，是文本处理和信息检索的重要工具。 6. 树和二叉树：树形结构，广泛用于表示层次关系和搜索问题。 7. 图...
刷题笔记——java学习
05-12
刷题笔记——java学习
LeetCode刷题笔记——63. 不同路径 II
12-21
【LeetCode刷题笔记——63. 不同路径 II】 一、题目描述： 在LeetCode的第63题中，我们被要求计算一个有障碍物的网格中从左上角到右下角的不同路径数量。网格由一个二维整数数组`obstacleGrid`表示，其中1代表障碍...
数据结构动画演示完整版
08-29
数据结构动画演示完整版，用动画看起来简单明了，更容易理解数据结构。
常见的数据结构Flash动画演示
08-11
常见的数据结构Flash动画演示有： 1 二叉树的删除、建立、查找，中序线索化二叉树等 2 huffman数的构建 3 多种排序算法 4 常见的图算法演示 5 hash算法演示 6 B数的生成、删除的演示 7 栈队列的演示 8 字符串匹配算法演示
【数据结构】栈和队列，看完这一篇就够了（万字配动图配习题）
jhao的博客
08-10 1626
注释： 压栈/进栈/入栈：栈的插入操作，入数据在栈顶 出栈： 站的删除操作，出数据也在栈顶来看看下面这个动图加深理解吧： 代码展示栈的结构: 常见接口： 2.初始化栈 3.压栈操作 4.出栈操作 栈是否为空 5.获取栈顶元素 6.获取栈中有效元素个数 7.销毁栈 二、队列 1.队列的结构 队列的结构会比栈的难懂一些，因为队列的属性就是先入先出，所以采用顺序表的话我们的头删就要去移动数据覆盖第一个位置，或者用一个指针记录头的位置，头删的时候用移动头节点来表示，但是这
【数据结构和算法】动图+万字，详解栈和队列（实例讲解）
Linux猿
09-26 7781
???? 作者：Linux猿 ???? 简介：CSDN博客专家????，华为云享专家????，C/C++、面试、刷题、算法尽管咨询我，关注我，有问题私聊！ ???? 关注专栏：C/C++面试通关集锦（优质好文持续更新中……）???? ???? 欢迎小伙伴们点赞????、收藏⭐、留言???? 目录 一、栈 1.1 什么是栈 1.2 实现方式 1.3 数组实现栈 1.3.0 类封装 1.3.1 push 操作 1.3.2 pop 操作 1.3.3 empty 操作 1.3.4 top
数据结构——队列（GIF图解）
weixin_43294413的博客
12-16 3163
一、队列的定义 队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表 队列也是一种线性结构； 队列是一种先进先出（First In First Out）的数据结构； 队列的描述如下图： 二、队列的实现 先定义一个接口Interface public interface Queue<E> extends Iterable<E>{ //获取队列中元素的个数 ...
【数据结构】队列（queue）-循环队列（动态图解、c++、java）
扑腾的江鱼复习仓库
01-19 3250
URLeisure的“完美”复习资料。
设计循环队列（图示超详解哦）
最新发布
weixin_73450183的博客
03-25 1002
我们需要实现循环队列的如下接口：MyCircularQueue(k): 构造器，设置队列长度为 k；Front: 从队首获取元素。如果队列为空，返回 -1；Rear: 获取队尾元素。如果队列为空，返回 -1；enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真；deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真；isEmpty(): 检查循环队列是否为空；isFull(): 检查循环队列是否已满。
数据结构与算法（六）——循环队列的顺序存储结构（超详解，附动图+代码）
站在远方看童年的博客
12-19 1375
上一篇最后我们分析了队列的利弊，故我们这里对队列进行优化。就有了这一篇，循环队列。 队列的问题主要便是入队的时间复杂度O(1).出队的时间复杂度0(n) 。还有就是当进行插入和删除操作后，线性表的开始空间可能会被空出来，会浪费且占用空间。 优化（循环队列）： 首先让队头指针和队尾指针一样随着数据元素的变化而变化。这样入队和出队的操作都是O(1)，然后我们将线性表首尾相连，当队头或队尾指针到达尾部时...
刷题笔记1
08-03
第三章、暴搜索算法回溯算法17. 电话号码的字组合22. 括号成37. 解数独39. 组合总和46. 全排列77. 组合78. 集51. N 皇后104. 叉树

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 160
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

天影云光

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

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

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

打赏作者

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

抵扣说明：

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

余额充值