手撕数据结构算法OJ——栈和队列

最新推荐文章于 2026-01-04 20:56:17 发布
原创 最新推荐文章于 2026-01-04 20:56:17 发布 · 1k 阅读 · 26 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #算法 #linux #开发语言 #c++ #c语言 #学习

文章目录

一、前言

兄弟们，今天的你们还在学习吗？快快跟随up的脚步，让up和大家一起长脑子吧！俗话说得好：一日学一日功，一日不学十日空。好啦言归正传，前面up已经给大家讲解完了栈和队列这两个数据结构，不知道你有没有把它们吃透呢？今天呢咱们就来手撕与之相关的算法OJ题。

二、手撕OJ

2.1有效的括号

力扣20题 有效的括号链接
在这里插入图片描述
条件限制：
1、只能有这三种括号( ) 、[ ]、{ }
2、左括号必须用相同类型的右括号闭合
3、左括号必须以正确的顺序闭合
4、每个右括号都有一个对应的相同类型的左括号
画图展示（用栈解决）：
注意阅图顺序：先从左往右，在从上往下。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
注意：因为此题是用栈来实现，关于栈的各功能up在上一次已经给大家书写过一次了，所以这里我们就直接复制粘贴。（如有疑问请查看上一节分享）
代码展示：

typedef char STDataType;
typedef struct Stack
{
	STDataType* arr;
	int top;
	int capacity;
}ST;
void StackInit(ST* ps)//栈初始化
{
	assert(ps);
	ps->arr = NULL;
	ps->top = 0;
	ps->capacity;
}
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->arr, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			printf("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newcapacity;
	}
	ps->arr[ps->top++] = x;
}
bool Stackempty(ST* ps)//判空
{
	assert(ps);
	return ps->top == 0;
}
void StackPop(ST* ps)//出栈
{
	assert(!Stackempty(ps));
	--ps->top;
}
STDataType StackFront(ST* ps)//取栈顶
{
	assert(!Stackempty(ps));
	return ps->arr[ps->top - 1];
}
int StackSIze(ST* ps)//有效个数
{
	assert(ps);
	return ps->top;
}
void StackDestroy(ST* ps)//销毁
{
	assert(ps);
	if (ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
//.......................以上为栈的各功能实现代码
bool isValid(char* s) {
    ST st;
    StackInit(&st);
    char* pi = s;
    while(*pi!='\0')
    {
        if(*pi == '(' || * pi == '[' || *pi =='{')
        {
            StackPush(&st,*pi);
        }
        else
        {
            if(Stackempty(&st))
            {
                StackDestroy(&st);
                return false;
            }
        char top = StackFront(&st);
        if((top == '(' && *pi != ')')
        ||(top == '[' && *pi != ']')
        ||(top == '{' && *pi != '}'))
        {
            StackDestroy(&st);
            return false;
        }
        StackPop(&st);
    }
    pi++;
    }
    bool ret = Stackempty(&st) ? true : false;
    StackDestroy(&st);
    return ret;
}

思路：定义一个pi从第一个括号开始,若pi为左括号则直接进栈，如果没有左括号只有右括号则注定无法匹配，return false;待遇到右括号就与栈顶的左括号进行匹配，如果没有右括号或者匹配不成功直接返回false,若匹配成功就出栈，继续用下一个右括号与栈顶进行匹配，当pi走到空并且栈中也没有元素的时候，说明全部括号匹配成功，return true.

提交通过：
在这里插入图片描述

2.2用队列实现栈

力扣225 用队列实现栈链接
在这里插入图片描述

2.2.1初始化

代码展示：

MyStack* myStackCreate() {//初始化
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&pst->q1);
    QueueInit(&pst->q2);
    return pst;
}

2.2.2入栈

画图展示：
在这里插入图片描述
思路：找到不为空的队列，把要进行入栈操作的元素直接入队即可。

代码展示：

void myStackPush(MyStack* obj, int x) {//入栈
    if(!Queueempty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}

2.2.3出栈

画图展示：
在这里插入图片描述
思路：找到不为空的队列，把队列的前size-1个元素入队到另外一个空队列中，待原先不为空的队列只剩一个元素的时候，把最后一个元素保存直接出栈掉即可，再反复进行以上操作，直到一 一出栈。

代码展示：

int myStackPop(MyStack* obj) {//出栈
    Queue* emp = &obj->q1;
    Queue* noneEmp = &obj->q2;
    if(Queueempty(&obj->q2))
    {
        emp = &obj->q2;
        noneEmp = &obj->q1;
    }
    while(QueueSize(noneEmp)>1)
    {
        QueuePush(emp,QueueFront(noneEmp));
        QueuePop(noneEmp);
    }
    int top = QueueFront(noneEmp);
    QueuePop(noneEmp);
    return top;
}

2.2.4取栈顶

画图展示：
在这里插入图片描述
思路：直接返回不为空的队列中的队尾元素即为所需要的栈顶元素。
代码展示：

int myStackTop(MyStack* obj) {//取栈顶
    if(!Queueempty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

2.2.5判空

思路：当队列1和队列2同时都不为空则栈不为空，反之有一个为空则栈为空。

代码展示：

bool myStackEmpty(MyStack* obj) {//判空
    return Queueempty(&obj->q1) && Queueempty(&obj->q2);
}

2.2.6销毁

思路：把队列1和队列2销毁掉，再把存放这两个队列的空间释放掉，最后再置为空即可。

代码展示：

void myStackFree(MyStack* obj) {//销毁
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
    obj = NULL;
}

2.2.7整体代码

注意：队列的实现是直接复制粘贴上一节的代码。

typedef int QDataType;
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QueueNode;
typedef struct Queue
{
	QueueNode* phead;
	QueueNode* ptail;
}Queue;
void QueueInit(Queue* pq)//初始化
{
	assert(pq);
	pq->phead = NULL;
	pq->ptail = NULL;
}
void QueuePush(Queue* pq,QDataType x)//入队
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		printf("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->phead == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = pq->ptail->next;
	}
}
bool Queueempty(Queue* pq)//判空
{
	assert(pq);
	return pq->phead == NULL;
}
void QueuePop(Queue* pq)//出队
{
	assert(!Queueempty(pq));
	if (pq->phead == pq->ptail)
	{
		free(pq->phead);
		pq->phead = NULL;
	}
	else
	{
		QueueNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}
}
QDataType QueueFront(Queue* pq)//取队头
{
	assert(!Queueempty(pq));
	return pq->phead->data;
}
QDataType QueueBack(Queue* pq)//取队尾
{
	assert(!Queueempty(pq));
	return pq->ptail->data;
}
int QueueSize(Queue* pq)//有效个数
{
	assert(pq);
	QueueNode* pcur = pq->phead;
	int size = 0;
	while (pcur)
	{
		size++;
		pcur = pcur->next;
	}
	return size;
}
void QueueDestroy(Queue* pq)//销毁
{
	assert(pq);
	QueueNode* pcur = pq->phead;
	while (pcur)
	{
		QueueNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	pq->phead = NULL;
	pq->ptail = NULL;
}


typedef struct {
    Queue q1;
    Queue q2
} MyStack;


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

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

int myStackPop(MyStack* obj) {
    Queue* emp = &obj->q1;
    Queue* noneEmp = &obj->q2;
    if(Queueempty(&obj->q2))
    {
        emp = &obj->q2;
        noneEmp = &obj->q1;
    }
    while(QueueSize(noneEmp)>1)
    {
        QueuePush(emp,QueueFront(noneEmp));
        QueuePop(noneEmp);
    }
    int top = QueueFront(noneEmp);
    QueuePop(noneEmp);
    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) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
    obj = NULL;
}

提交通过：
在这里插入图片描述

2.3用栈实现队列

力扣232 用栈实现队列链接
在这里插入图片描述

2.3.1初始化

代码展示：

MyQueue* myQueueCreate() {//初始化
    MyQueue* pq = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&pq->pushST);
    StackInit(&pq->popST);
    return pq;
}

2.3.2入队

画图展示：
在这里插入图片描述
思路：直接把要入队的元素入栈即可。

代码展示：

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

2.3.3出队

画图展示：
在这里插入图片描述
思路：把原来不为空的栈中的元素依次入栈到另外一个空栈中，此时原先的空栈的栈顶元素就是要出队的元素，直接把队头出队即可

代码展示：

int myQueuePop(MyQueue* obj) {//出队
    if(Stackempty(&obj->popST))
    {
        while(!Stackempty(&obj->pushST))
        {
            StackPush(&obj->popST,StackFront(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    int top = StackFront(&obj->popST);
    StackPop(&obj->popST);
    return top;
}

2.3.4取队头

画图展示：
在这里插入图片描述
思路：把原来不为空的栈中的元素依次入栈到另外一个空栈中，此时原先的空栈的栈顶元素就是队头。

代码展示：

int myQueuePeek(MyQueue* obj) {//取队头
    if(Stackempty(&obj->popST))
    {
        while(!Stackempty(&obj->pushST))
        {
            StackPush(&obj->popST,StackFront(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    return StackFront(&obj->popST);
}

2.3.5判空

思路：两个栈同时不为空即队列不为空，反之有一个栈为空则队列为空。

代码展示：

bool myQueueEmpty(MyQueue* obj) {//判空
    return Stackempty(&obj->pushST) && Stackempty(&obj->popST);
}

2.3.6销毁

思路：把两个栈销毁掉，再把存放这两个栈的空间释放掉，最后再置为空即可。

代码展示：

void myQueueFree(MyQueue* obj) {//销毁
    StackDestroy(&obj->pushST);
    StackDestroy(&obj->popST);
    free(obj);
    obj = NULL;
}

2.3.7整体代码

注意：栈的各功能实现是直接复制粘贴上一节的代码。

typedef int STDataType;
typedef struct Stack
{
	STDataType* arr;
	int top;
	int capacity;
}ST;
void StackInit(ST* ps)//栈初始化
{
	assert(ps);
	ps->arr = NULL;
	ps->top = 0;
	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->arr, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			printf("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newcapacity;
	}
	ps->arr[ps->top++] = x;
}
bool Stackempty(ST* ps)//判空
{
	assert(ps);
	return ps->top == 0;
}
void StackPop(ST* ps)//出栈
{
	assert(!Stackempty(ps));
	--ps->top;
}
STDataType StackFront(ST* ps)//取栈顶
{
	assert(!Stackempty(ps));
	return ps->arr[ps->top - 1];
}
int StackSIze(ST* ps)//有效个数
{
	assert(ps);
	return ps->top;
}
void StackDestroy(ST* ps)//销毁
{
	assert(ps);
	if (ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->top = 0;
	ps->capacity = 0;
}


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


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

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,StackFront(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    int top = StackFront(&obj->popST);
    StackPop(&obj->popST);
    return top;
}

int myQueuePeek(MyQueue* obj) {
    if(Stackempty(&obj->popST))
    {
        while(!Stackempty(&obj->pushST))
        {
            StackPush(&obj->popST,StackFront(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    return StackFront(&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);
    obj = NULL;
}

提交通过：
在这里插入图片描述

四、总结

宝子们，怎么样？是否被这三道OJ题震撼到了呢？相信你在看完up的分析之后，可能会感慨——原来栈和队列还能这么用,真NB。不过震撼归震撼，下来还是得深入理解。up期待大家更上一层楼。

这世界上，最富有的人是跌倒最多的人；最勇敢的人是每次跌倒都能站起来的人；最成功的人是那些每次跌倒，不单能站起来，还能够坚持走下去的人
在这里插入图片描述

鑫—萍
关注
2025华为OD机试（C++）真题【E卷+A卷+B卷+C卷+D卷】目录+在线OJ
MISAYAONE的博客
09-21 19万+
华为OD机试真题题库【E卷+A卷+B卷+C卷+D卷】目录，C++实现。
算法题目录
热门推荐
优快云
11-18 51万+
考点分类考点分类按照算法考点对题目进行划分整理，刷一题了解一类题型，短时间速通ACM输入输出处理常规ACM模式输入输出处理对Java、JS、Python的控制台输入输出做了详细的介绍，以及难点，易错点总结ACM模式不定行输入处理策略技术面手撕算法题技术面 - 手撕算法题整理收集并整理考友反馈的高频面试真题技术面八股文整理技术面 - 八股文整理收集并整理考友反馈的高频八股文问题。
[数据结构] 用两个栈实现队列详解
weixin_67596609的博客
03-22 4424
在数据结构中，栈和队列是较为常见的两种数据结构。。那怎么用栈去实现队列呢？此问题在面试中也是高频出现的问题。本篇文章会给出详细解释。
4.2较难的栈和队列OJ
E_han的博客
08-24 722
本篇博客来手撕三道稍有难度的栈和队列相关OJ，题目均已插入超链接，点击即可跳转~
数据结构——二叉树OJ题目强训
qq_67611811的博客
09-01 814
二叉树有很多变种形式，比如单值二叉树，两棵数值上完全相同的树，两棵轴对称的树，一棵树为另一棵更大树的子树等等。因为树本身采取的是一种分治递归向下遍历的思路，所以对不同结构的树进行挖掘和思考可以让我们对二叉树这个概念有更好的了解，本章将详细介绍几种变种二叉树并随附代码解析。...
数据结构初阶——树和二叉树/堆
weixin_73870552的博客
04-26 1190
int size;// 当前数据个数// 容量}HP;数据类型是inta记录一段连续的地址空间，就是数组。普通二叉树的增删查改没有意义，真正有意义的是搜索树，平衡树，红黑树这些复杂的二叉树。但是学习控制普通二叉树的结构，是有意义的。在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。
【数据结构】手撕二叉树oj练习与经典问题
qq_61386381的博客
08-03 855
二叉树经典问题 一、结点个数 二、叶结点个数 三、第K层结点个数 四、二叉树的深度 五、二叉树查找值为x的节点 六、二叉树的销毁 七、判断二叉树是否是完全二叉树 二叉树OJ练习 965. 单值二叉树 - 力扣（LeetCode） 100. 相同的树 - 力扣（LeetCode） 101. 对称二叉树 - 力扣（LeetCode） 572. 另一棵树的子树 - 力扣（LeetCode） 二叉树遍历_牛客题霸_牛客网 (nowcoder.com)............
数据结构初阶（6）栈 && 队列·面试题
2301_79907403的博客
08-08 1081
栈 && 队列·面试题
手撕初阶数据结构之二叉树
liu3290607528的博客
06-19 1105
上篇博客小L已经讲述了二叉树的基本性质目前初阶数据结构最难的一集-树+二叉树_堆-优快云博客，这期我将带领大家一起进行二叉树的具体实现，由于普通二叉树实在太复杂，于是我们这节要一步步从零开始，那么就让我们系好安全带，一起向二叉树前进吧！！！
手撕数据结构---------顺序表和链表
2301_80863610的博客
07-25 5141
定义之前已经知道数组大小的数组定义之前不知道数组大小的数组---动态内存管理int *arr---定义一个指针sequence:流畅的 List:表那么对顺序表的定义1.已知顺序表的大小:静态顺序表：int size;//顺序表中有效数据的个数如果我们一开始不知道顺序表的大小的话，在后面代码生成的时候申请了大小，这就是动态顺序表对于顺序表，我们不一定是整型数组，可能是字符数组，那么这个时候我们就要用到typedef了，将数据类型重命名，因为这样会很方便的，如果一个个改的话就很麻烦。
字节跳动程序媛教你如何刷算法题：面试手撕代码我就没怕过
Stay Hungry Stay Foolish 求知若饥 虚心若愚
02-11 2万+
本人上一次刷题还是大一的C语言期末考试……但是面试中算法考核截止上岸前一直保持着100%正确率的光辉记录。 本文将给你指明一条刷题的决胜指南。并从算法的重要性、题库的选择以及刷题的三大步骤分别进行讲解，彻底解决你所有关于面试算法所有的困扰。
华为面试手撕真题【课程表】
MISAYAONE的博客
08-21 1996
华为面试手撕真题【课程表】
Python算法入门与提高：刷题与就业必备
常见的数据结构如数组、链表、栈、队列、哈希表、堆（优先队列）、树（二叉树、二叉搜索树、平衡二叉树AVL、红黑树）、图等，都是算法实现不可或缺的组成部分。例如，在解决“两数之和”问题时，利用哈希表可以在O(n...
数据结构 b+树
似流水般平静而坚定。
12-30 314
本文实现了一个B+树数据结构，包含完整的插入、删除、查找和范围查询功能。B+树采用M阶结构（示例中M=4），具有以下特点：1) 内部节点存储索引关键字；2) 叶子节点通过链表连接便于范围查询；3) 支持数据指针存储。核心算法包括节点分裂/合并处理上溢/下溢情况，通过递归调整保持树平衡。实现提供了详细的API接口，包括初始化、插入、删除、查找、范围查询和销毁操作，并包含调试显示功能。该实现采用C语言编写，使用动态内存管理，通过断言检查参数有效性，确保数据结构的正确性和健壮性。
Matlab入门案例介绍—常用的运算符及优先级
m0_59012156的博客
01-01 573
本文介绍了MATLAB中常用的运算符及其应用。算术运算符包括基本运算（+,-,,/,^）和矩阵运算（.,./,.^）等；关系运算符（==,~=,>,<,>=,<=）用于比较数值或矩阵；逻辑运算符分为元素级（&,|,~）和短路型（&&,||）。文章详细说明了各类运算符的使用方法、应用场景和注意事项，特别强调了矩阵运算与数组运算的区别。最后总结了MATLAB运算符的优先级顺序，括号运算具有最高优先级。这些运算符是MATLAB编程的基础组成部分，广泛应用于矩阵运算、
【C语言】堆(Heap)的数据结构与实现：从构建到应用
qq_67169366的博客
01-04 680
结构特性：堆是一棵完全二叉树，意味着除了最后一层，其他层都是满的，且最后一层的节点都靠左排列顺序特性大根堆：父节点的值 ≥ 子节点的值小根堆：父节点的值 ≤ 子节点的值堆顶特性：堆顶元素（根节点）是整个堆中的极值元素操作时间复杂度说明插入O(log n)向上调整删除堆顶O(log n)向下调整获取堆顶O(1)直接访问建堆O(n log n)逐个插入优化建堆O(n)Floyd算法堆排序O(n log n)所有元素出堆。
十大经典排序算法详解（附C语言实现+复杂度分析）
weixin_44977283的博客
01-04 559
本文系统介绍了十大经典排序算法，包括冒泡排序、选择排序、插入排序等基础算法，以及希尔排序、快速排序、归并排序等进阶算法。详细解析了各算法的原理、C语言实现、时间/空间复杂度及稳定性特点，并提供了可直接运行的代码示例。特别对线性时间排序算法（桶排序、计数排序、基数排序）进行了深入讲解。最后总结各算法的适用场景，建议小规模数据使用基础排序，大规模数据选择快速排序或归并排序，特定场景考虑线性时间排序。所有代码均经过验证，可通过调整比较逻辑实现升序或降序排列。
408真题解析-2009-10-数据结构-排序
最新发布
tobias的博客
01-04 316
摘要：本文分析2009年一道排序算法选择题，题目要求根据第二趟排序结果反推所用算法。通过排除法：冒泡和选择排序会固定极值位置（不符合），二路归并排序第二趟应有4元素有序段（不符合），最终确定是插入排序（前3个元素有序）。总结各排序算法"趟"的特征：插入排序前k+1个有序，冒泡排序末尾k个有序，选择排序前k个有序，归并排序每2^k个元素有序。答案为B（插入排序）。
【C++】JSON核心数据结构解析及JSONCPP使用
Ape's IT Blog
01-04 691
JSON是一种轻量级数据交换格式，基于键值对组织数据，支持字符串、数字、布尔值、null等基础类型，以及对象和数组两种复合结构。JSON对象是无序键值对集合，数组是有序值列表。实际应用中常组合使用对象和数组表示复杂数据，如列表型数据和多层级结构。JSON语法严格，要求键必须用双引号、末尾不能有多余逗号。JsonCpp是C++的JSON处理库，核心类Json::Value可表示所有JSON数据类型，通过类型枚举区分不同结构。JSON广泛应用于前后端交互和数据存储，是跨平台数据交换的首选格式。
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值