【数据结构】栈和队列

已于 2023-03-04 18:25:27 修改
阅读量363 收藏 1
点赞数
分类专栏： 数据结构 文章标签： c语言
于 2022-11-23 18:36:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhhkkksa/article/details/127945792
版权

目录

栈的基本概述

栈的程序实现

栈的实现

Stack.h

Stack.c

Test.c

队列的基本概述

队列的程序实现

队列的实现

Queue.h

Queue.c

Test.c

栈和队列oj练习题

有效的括号

用队列实现栈

栈的基本概述

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除
操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）
的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶。

栈的程序实现

栈的实现

顺序表解决了头删头插的难题，但需要增容
链表

如果是单链表，则在尾删尾插时，需要找到尾节点的前驱，这是比较麻烦的：

1.双向链表，在节点内多定义一个prev指针

2.逆向思维，出栈入栈看作链表的头插头删

Stack.h

#pragma once
#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#include<assert.h>
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);
int StackSize(ST* ps);
bool StackEmpty(ST* ps);

Stack.c

StackInit

和动态顺序表极其类似，malloc一个空间

值得注意的是：

如果top = 0，则意味着 ps->a[top]没有存储数据，入栈的时候先录入数据再++，且 top == 实际栈中的数据个数。

如果top = -1，则意味着 ps->a[top]存储了有效数据，入栈时先++再录入数据，且top == 实际栈中数据个数 - 1

void StackInit(ST* ps)
{
	assert(ps);
	ps->a = (STDataType*) malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	ps->capacity = 4;
	ps->top = 0;
}

StackDestory

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

StackPush

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		STDataType*tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capacity * 2);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity *= 2;
		}
	}
	ps->a[ps->top] = x;
	ps->top++;
}

StackPop

出栈

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

StackTop

获取栈顶元素

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

注意assert，如果top == 0时，则说明栈中没有数据了

StackSize

int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

StackEmpty

判断栈是否为空

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

注意，这里使用了布尔值，如果ps->top == 0，则返回true

Test.c

#define _CRT_SECURE_NO_WARNINGS

#include"Stack.h"

void TestStack()
{
	ST st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);
	StackPush(&st, 5);
	printf("%d\n", StackSize(&st));
	while (!StackEmpty(&st))
	{
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}
	printf("\n");
	printf("%d", StackSize(&st));
	StackDestory(&st);
}
{
	TestStack();
	return 0;
}

队列的基本概述

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

队列的程序实现

队列的实现

队列最重要的性质是：队头出队，队尾入队，而我们之前学过的单链表，头删和尾插是能够十分便捷的完成这一功能，所以我们需要使用单链表作为队列的基本结构。

但是值得注意的是：在进行尾插的时候，我们需要知道尾节点的地址，而遍历会让程序变得冗余。所以与单链表不同的是，我们需要定义一个tail，目的是指向尾节点，这样子可以极大提高程序运行效率。

Queue.h

这里与单链表不同的是，在一个队列中，我们需要定义两个指针，一个指向队头，进行头删；一个指向队尾，进行尾删。所以我们不妨将这两个量也封装成一个结构体，每次都从这个结构体内调用head和tail。

第二个结构体，就是我们常规的单链表的结构体了，节点中有一个后驱和存储的数据。

值得注意的是：由于我们在函数中会修改结构体的值，所以在函数传参的时候，我们会采用传址传参的方法，即传入结构体的指针

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

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);
//取队头的数据
QDataType QueueFront(Queue* pq);
//取队尾的数据
QDataType QueueBack(Queue* pq);
int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);

Queue.c

QueueInit

初始化队列：即将pq内的tail和head置空

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

QueueDestory

销毁队列：这里我们每次入队，都会malloc一个新的内存空间，所以我们需要依次释放这些内存空间，需要遍历整个队列，而不是简单地置空pq这个结构体

void QueueDestory(Queue* pq)
{
	QNode* cur = pq->head;
	//销毁需要将所有申请的内存空间全部置空
	//所以需要遍历+free
	while (cur)
	{
		QNode* tmp = cur->next;
		free(cur);
		cur = tmp;
	}
	pq->head = pq->tail = NULL;
}

QueuePush

入队，即单链表中的尾插。这里与尾插有不同的地方是：我们多定义了一个tail指针，当队列没有节点时，即head和tail均为空，我们需要额外将head和tail赋值为新节点。

void QueuePush(Queue* pq, QDataType x)
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	newnode->next = NULL;
	newnode->data = x;
	if (newnode == NULL)
	{
		printf("malloc fail!\n");
		exit(-1);
	}
	assert(pq);
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

QueuePop

出队，相当于单链表中的头删法

我们也是需要分情况讨论

1.当队列中还有一个以上的节点时：

进行头删法，注意先保存head->next，再释放head

2.当队列中只有一个节点时，即head == tail：

为了防止tail成为野指针，我们需要直接将head释放，并将head和tail置空

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	//删除到最后一个节点时，tail会变成野指针
	//还剩多个节点时
	if (pq->head->next)
	{
		QNode* tmp = pq->head->next;
		free(pq->head);
		pq->head = tmp;
	}
	//删除到只剩最后一个节点时：head->next为空
	else
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
		//将head和tail置空，恢复成初始化后的情形
	}
}

QueueFront

取队头的节点，注意断言：没有节点时需要断言

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

QueueBack

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

QueueSize 

注意循环条件 cur不为空，当cur为最后一个节点时，仍需要进入循环，size++

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

QueueEmpty

判断队列是否为空，返回值是布尔值

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	if (pq->head)
	{
		return false;
	}
	else
	{
		return true;
	}
}

Test.c

#include"Queue.h"
void TestQueue()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePop(&q);
	printf("%d\n", QueueSize(&q));
	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	QueueDestory(&q);
}
int main()
{
	TestQueue();
	return 0;
}

栈和队列oj练习题

有效的括号

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

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。
  3. 每个右括号都有一个对应的相同类型的左括号。

示例 1：

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

示例 2：

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

示例 3：

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

提示：

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

来源：力扣（LeetCode）

链接：https://leetcode.cn/problems/valid-parentheses/

思路：

括号匹配的本质是：如果出现一个左括号，在这个左括号后有且只有一个右括号与之匹配。

这题难点在于：我们不知道和左括号匹配的右括号具体位置在哪。

我们先考虑括号匹配的情况：

例如：

"(){}{}"        "[(){}]"        "{[()]}"

我们可以注意到，括号匹配的字符串有一个关键，至少会有一个相连的括号对存在！

"(){}{}"        "[(){}]"        "{[()]}"

然后我们可以发现：如果将这个相连的括号对删去，我们可以很欣喜的发现：

再次出现了至少一个相连的括号对

"(){}"        "[]"        "{[]}"

如此反复，全部元素被删除完毕后，则一定是匹配的

那我们接下来考虑其他不匹配的情况：

1.例如：

"{{"        "{{{}}"

只有左括号和右括号，或者左右括号数量不相等：

这显然不成立，依据上述算法，不可能将所有括号删除

2.例如

"(([)])"        "(}"

左右括号数量相等，但是没有相连，这也不能进行删除，所以不会清空字符串。

所以，我们可以得到一个思路：找到相连的括号对，进行删除。

所以，我们可以利用栈来实现这个思路。

typedef char STDataType;
typedef struct Stack
{
    STDataType* s;
    int Top;
    int capacity;
}ST;
void StackInit(ST* ps)
{
    assert(ps);
    ps->Top = 0;
    ps->capacity = 4;
    ps->s = (STDataType*)malloc(sizeof(STDataType) * 4);
}
void StackDestory(ST* ps)
{
    assert(ps);
    free(ps->s);
    ps->capacity = ps->Top = 0;
}
void StackPush(ST* ps, STDataType x)
{
    assert(ps);
    if (ps->capacity == ps->Top)
    {
        STDataType* tmp = (STDataType*)realloc(ps->s, sizeof(STDataType) * ps->capacity * 2);
        if (tmp == NULL)
        {
            printf("realloc fail\n");
            exit(-1);
        }
        else
        {
            ps->s = tmp;
            ps->capacity *= 2;
        }
    }
    ps->s[ps->Top] = x;
    ps->Top++;

}
void StackPop(ST* ps)
{
    assert(ps);
    assert(ps->Top);
    ps->Top--;
}
STDataType StackTop(ST* ps)
{
    assert(ps);
    assert(ps->Top);
    return ps->s[ps->Top - 1];
}
bool StackEmpty(ST* ps)
{
    assert(ps);
    return !ps->Top;
}
bool isValid(char* s)
{
    //初始化一个栈，用于存放字符串s
    ST st;
    StackInit(&st);
    //遍历字符串中所有的字符
    int i = 0;
    while (s[i] != '\0')
    {
        switch (s[i])
        {
            //如果是这三个左括号，则入栈
        case '(':
        case '{':
        case '[':
        {
            StackPush(&st, s[i]);
            break;
        }
        //如果是这三个右括号，则取出栈顶的元素与之进行匹配
        //如果匹配成功，则继续；如果匹配不成功，则返回false
        case ')':
        case '}':
        case ']':
        {
            if (StackEmpty(&st))
            {
                StackDestory(&st);
                return false;
            }
            char Top = StackTop(&st);
            StackPop(&st);
            //不匹配
            if ((Top == '(' && s[i] != ')')
                || (Top == '{' && s[i] != '}')
                || (Top == '[' && s[i] != ']'))
            {
                StackDestory(&st);
                return false;
            }
        }
        }
        i++;

    }
    //实际上，只有左括号可以入栈，如果有匹配的右括号，则出栈
    //所以，当栈为空时，说明s中所有的字符都匹配
    bool ret = StackEmpty(&st);
    StackDestory(&st);
    return ret;

}

注意：记得释放空间，防止内存泄漏

用队列实现栈

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

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/implement-stack-using-queues

 思路：

定义两个队列：

Queue11234
Queue2

队列的特点是：先入先出        栈的特点是：后入先出

所以我们需要将队尾的元素依次取出

1.将Queue1中除队尾所有的元素依次入队至Queue2中

Queue14
Queue2123

2.将Queue1中的元素出队

Queue1
Queue2123

 从此循环，直至所有元素出队

这就模拟了入栈和出栈的模式，基本实现了栈的功能

初始化

MyStack* myStackCreate() 
{
    MyStack* ps = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(ps->Queue1);
    QueueInit(ps->Queue2);
    if (ps == NULL)
    {
        printf("malloc fail\n");
        exit(-1);
    }
    return ps;
}

入栈

按照上述思路，应该往有数据的队列中入数据

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)
{
    //先假设q1为空，q2不为空
    QNode* emptyq = &obj->q1;
    QNode* nonemptyq = &obj->q2;
    //找到不为空的队列
    if (!QueueEmpty(&obj->q1))
    {
        emptyq = &obj->q2;
        nonemptyq = &obj->q1;
    }
    //倒数据
    while (QueueSize(nonemptyq) > 1)
    {
        QueuePush(emptyq,QueueFront(nonemptyq));
        QueuePop(nonemptyq);
    }
    int top = QueueFront(nonemptyq);
    QueuePop(nonemptyq);
    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);
}
zhangyuaizhuzhu
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
栈的使用（push、pop详解）学习笔记
weixin_42492218的博客
11-14 2万+
概念： 栈是一种数据结构，可以添加或者删除值，不过要遵循“后进先出”的原则。通过 push 操作把数据压入栈中，通过pop操作删除数据；它具有一个属性：弹出的值永远是最近被压入而且仍然在栈中的值。 栈可以实现为一个数组，总是从数组的一端插入和删除元素。这一端被称为栈顶。在x86-64中，程序栈存放在内存中某个区域。栈顶元素的地址是所有栈中元素地址中最低的。(根据惯例，我们的栈是倒过来画的，栈“顶”在图的底部。)栈指针%rsp保存着栈顶元素的地址。 PUSHQ与...
C++-queue：queue基本用法【q.push(x)、q.front()、q.back()、q.pop()、q.size()、q.empty()】
u013250861的博客
12-20 1万+
为了降低时间复杂度，将数组当作一个首尾相连的圆环，分别用两个标志front、rear代表队列的头部和尾部。删除元素时，队首标志往后移，添加元素时，若队尾没有空间，考虑数组的头部空间若还有，则在队头添加元素，防止数组内存空间的流失。出队操作：数组头部元素出队之后，头部之后的元素均需要往前移动一个位置，时间复杂度为O（n）设置一个标志变量flag，同时满足front=rear且flag=1时为满队列。入队操作：在数组的末尾添加元素，时间复杂度为O（1）链表头为队列头部，链表尾为队列尾部。空一个元素，保持为空。
C++ STL 中的 priority_queue::push() 和 priority_queue::pop()
最新发布
csdn_aspnet的专栏
06-10 802
优先级队列是一种容器适配器，经过专门设计，队列的第一个元素要么是队列中所有元素中最大的，要么是最小的。我们还可以创建一个优先级队列，在创建优先级队列时只需传递一个额外的参数，将最小的元素放在顶部。该元素被添加到优先级队列容器中，队列的大小增加 1。首先，将元素添加到后面，同时优先级队列的元素根据优先级重新排序。应用：push() 和 pop()给定一些整数，将它们添加到优先级队列，并在不使用 size 函数的情况下找到优先级队列的大小。2. 不断弹出优先级队列的元素，直到队列为空，并增加计数器变量。
数据结构——线性结构（2）——链栈中的push和pop操作
redAnt的博客
08-26 2万+
链栈尽管数组是堆栈最常见的底层表示形式，但也可以使用链表实现Stack类。 如果这样做，空堆栈的概念表示就是NULL指针： 当你将新元素推入堆栈时，该元素只会添加到链表的前端。因此，如果将元素e1 push到空栈上，该元素将存储在一个新单元格中，该单元格将成为链中唯一的链接： 将一个新元素push栈将该元素添加到链的开头。所涉及的步骤与将字符插入链表列表缓冲区所需的步骤相同。 首先分配一
数据结构栈（顺序栈、链栈、插入push、删除pop）、队（循环队，链队、入队push，出队pop）知识点梳理
weixin_45709829的博客
11-03 8079
数据结构栈知识点梳理 一 栈的定义 栈（stack）是限定仅在表尾进行插入和删除操作的线性表 不含任何元素的栈称为空栈 允许插入和删除的一端成为栈顶（top），另一端称为栈底（bottom） 具有LIFO（Last In First Out）结构 栈元素具有线性关系，即前驱和后继，是特殊的线性表 二 栈的插入、删除 栈的插入操作—进栈（push） 栈的删除操作—出栈（pop） 三 栈的抽象数据类型 ADT 栈(stack) Data 同线性表。元素具有相同的类型，相邻
栈的基本运算（Push，Pop，初始化等）有给源码和详细注释
2301_80035594的博客
12-20 776
栈的基本运算（Push，Pop，初始化等）有给源码和详细注释
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作，这一端称为栈顶(top)。另一端称为栈底(bottom)，不允许在其上进行...
数据结构栈和队列相关习题及答案
04-20
数据结构栈和队列相关习题及答案
数据结构栈和队列（参考代码）
06-18
### 数据结构栈和队列知识点解析 #### 一、栈的基本概念与操作 **栈**是一种特殊的线性表，只允许在一端进行插入和删除操作，这一端被称为栈顶，另一端被称为栈底。栈遵循先进后出（First In Last Out, FILO）的...
数据结构栈和队列练习题答案.doc
04-02
数据结构
数据结构栈和队列解决迷宫问题
06-07
数据结构栈和队列解决迷宫问题 本文档详细介绍了利用栈和队列解决迷宫问题的步骤，对于初学者学习数据结构能很好的进行辅导。本文档主要涉及到数据结构的两个重要概念：栈和队列，并介绍了如何使用这两个数据结构来...
STL之queue使用
tianyexing2008的博客
02-19 5062
std::queue是一种先进先出的数据结构，它并不是一个真正的容器，而是一处适配器，它是对std::deque的包装。其定义如： 模板的第二个参数指定了queue的实现是std::deque。 1，std::queue的push操作 如果std::queue保存的对象，则push操作时，会调用对象的拷贝构造函数，插入queue中的是对象的一份拷贝。 #include <queue> #include <iostream> #include <string.h&.
一个栈，只提供push,pop,top,empty四种操作（这四种操作就是C++标准里的操作），对该栈的元素进行排序。
jiyanfeng1的专栏
01-16 2878
#include #include #include using namespace std; stack sort_stack( stack st ) { stack st1; while(!st.empty()) { int temp = st.top(); st.pop(); while(!st1.empty() && temp>st1.top()) { st
数据结构3：栈和队列
weixin_47921628的博客
10-10 227
数据结构：栈和队列的使用和实现；
菜鸟：模拟栈和队列的push和pop
张圣华的博客
05-15 5876
作为一个计算机行业的菜鸟，以前总是听说什么计算机思想，算法思想什么的，一直觉的离我很遥远，现在突然发现将思想转化成代码，是那么的有成就感啊！突然有种高达上的额感觉。初出茅庐，还请各位大神指导指导。在这里提前跪谢！
面试题：使用两个栈来实现一个队列，完成队列的Push和Pop操作
热门推荐
dangzhangjing97的博客
08-07 4万+
栈的特性：先进后出 队列的特性：先进先出 解析：使用两个栈来实现一个队列，其实就是组合两个栈，来实现队列，栈是先进后出，队列是先进先出，可使用以下操作使用栈来实现队列： 入队列： 1、把需要存放的元素插入到栈1中 出队列： 1、把栈1中的元素依次插入到栈2中 ps：此时栈顶元素就是需要出队列的元素...
数据结构栈和队列：基本运算与应用
"队列的基本运算-数据结构栈和队列PP" 在计算机科学中，数据结构是组织和存储数据的方式，以便高效地访问和修改。本资源主要关注两种特殊的数据结构：栈和队列，它们都是线性数据结构的变体。 栈是一种“后进先出...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值