【leetcode】学了栈和队列却觉得无用武之地？试试这几道题目吧！

news2024/9/24 11:27:30

目录

0.写在前面

1.leetcode.20 有效的括号

2.leetcode.225 用队列实现栈

3.用栈实现队列

4.设计循环队列

0.写在前面

这些题目所用语言为C语言，由于C语言未提供栈和队列的数据结构，所以需要我们手动实现栈和队列。此外熟练掌握栈和队列的性质对解题尤为重要。如果忘记了栈和队列的使用方法可在此直接跳转到栈和队列详解篇。

＜栈＞的概念&结构&实现【C语言版】icon-default.png?t=MBR7http://t.csdn.cn/lqe2X＜队列＞的概念&结构&实现【C语言版】icon-default.png?t=MBR7http://t.csdn.cn/iXiZI

1.leetcode.20 有效的括号

OJ链接：有效的括号（点此跳转）

解题思路：遍历字符串，如果碰到 ' ( ' 或 ' [ ' 或 ' { ' 就入栈；如果碰到字符是 ' ) ' ，栈顶的元素又是 ' ( '，就将栈顶的元素出栈。其他两种情况与之类似。

解题实战：

typedef char STDataType;

typedef struct Stack
{
	STDataType* a;  //动态开辟数组
	int capacity; //记录栈的容量大小
	int top; //记录栈顶的位置
}Stack;

//栈的初始化
void StackInit(Stack* ps);
//释放动态开辟的内存
void StackDestroy(Stack* ps);
//压栈
void StackPush(Stack* ps, STDataType data);
//出栈
void StackPop(Stack* ps);
//读取栈顶的元素
STDataType StackTop(Stack* ps);
//判断栈是否为空
bool StackEmpty(Stack* ps);
//栈存储的数据个数
int StackSize(Stack* ps);

void StackInit(Stack* ps)
{
	assert(ps);
	//初始化时，可附初值，也可置空
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

void StackDestroy(Stack* ps)
{
	assert(ps);
	//若并未对ps->a申请内存，则无需释放
	if (ps->capacity == 0)
		return;
	//释放
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

void StackPush(Stack* ps,STDataType data)
{
	assert(ps);
	//若容量大小等于数据个数，则说明栈已满，需扩容
	if (ps->capacity == ps->top)
	{
		//若为第一次扩容，则大小为4，否则每次扩大2倍
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		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] = data;
	ps->top++;
}

void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	//出栈
	ps->top--;
}

STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	//返回栈顶的数据
	return ps->a[ps->top - 1];
}

bool StackEmpty(Stack* ps)
{
	assert(ps);
	//返回top
	return ps->top == 0;
}

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}
bool isValid(char* s) {
    Stack ST;
    StackInit(&ST);

    int pos=0;
    //遍历字符串，遇到'\0'结束
    while(*(s+pos) != '\0')
    {
        if(*(s+pos) == '(' || *(s+pos) == '[' || *(s+pos) == '{')
        {
            StackPush(&ST,*(s+pos));
        }
        else
        {
            if(StackEmpty(&ST))
                return false;
            if((ST.top != 0) &&
               (*(s+pos) == ')' && StackTop(&ST) == '(')||
               (*(s+pos) == ']' && StackTop(&ST) == '[')||
               (*(s+pos) == '}' && StackTop(&ST) == '{'))
            {
                StackPop(&ST);
            }
            else
            {
                return false;
            }
        } 

        pos++;
    }

    if( StackEmpty(&ST) )
    {
        return true;
    }
    else
    {
        return false;
    }
}

2.leetcode.225 用队列实现栈

OJ链接：用队列实现栈

解题思路：首先我们要清楚栈和队列的性质：

栈：先进后出。只在尾部删数据。

队列：先进先出。只在头部删数据。

也就是说，添加数据时，两个是一样的，区别在于删数据时。栈要pop一个数据时，其实pop的是队尾的数据，而不巧的是，队列不能在队尾pop数据。所以此时，我们用两个队列来完成。

栈的结构定义用两个队列来实现。

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

使用两个队列的目的是，其中一个队列用来存储数据，另外一个空的队列在pop的时候用来接收非空的队列的数据。非空队列将数据全部拷贝到空队列，只留下一个队尾的数据，此时，队列只剩一个元素，它既在队尾也在队头，所以就可以pop了。

解题实战：

typedef int QDataType;

typedef struct QueueNode
{
	QDataType data; //存储的数据
	struct QueueNode* next; //记录下一个结点的位置
}QNode;

typedef struct Queue
{
	QNode* head; //记录队头的位置
	QNode* tail; //记录队尾的位置
	int size; //记录队列的长度
}Queue;

//队列的初始化
void QueueInit(Queue* pq);
//释放malloc出的内存
void QueueDestroy(Queue* pq);
//入队
void QueuePush(Queue* pq, QDataType x);
//出队
void QueuePop(Queue* pq);
//获取队头的数据
QDataType QueueFront(Queue* pq);
//获取队尾的数据
QDataType QueueBack(Queue* pq);
//判断队列是否为空
bool QueueEmpty(Queue* pq);
//队列数据的个数
int QueueSize(Queue* pq);
void QueueInit(Queue* pq)
{
	assert(pq);

	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);
	//用cur找尾
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* del = cur;
		cur = cur->next;

		free(del);
	}
	pq->size = 0;
	pq->head = pq->tail = NULL;
}

void QueuePush(Queue* pq,QDataType data)
{
	assert(pq);

	QNode* newNode = (QNode*)malloc(sizeof(QNode));
	if (newNode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	//初始化结点
	newNode->data = data;
	newNode->next = NULL;

	if (pq->tail == NULL)
	{
		//队列为空时入队
		pq->head = newNode;
		pq->tail = newNode;
	}
	else
	{
		//队列不为空时入队
		pq->tail->next = newNode;
		pq->tail = newNode;
	}
	
	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->size==0;
	return pq->head == NULL && pq->tail == NULL;
}

int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}


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


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

void myStackPush(MyStack* obj, int x) {
    //找一个不为空的队列来push数据
    Queue* noneQueue=(&obj->q1)->size == 0?&obj->q2:&obj->q1;
    QueuePush(noneQueue,x);
    obj->size++;
}

int myStackPop(MyStack* obj) {
    //找空队列
    if ((obj->q2).size == 0)
    {
        QDataType top;
        //复制数据
        while ((&obj->q1)->size > 1)
        {
            top = QueueFront(&obj->q1);
            QueuePop(&obj->q1);
            QueuePush(&obj->q2,top);
        }
        top=QueueFront(&obj->q1);
        QueuePop(&obj->q1);
        obj->size--;
        return top;
    }
    else
    {
        QDataType top;
        //复制数据
        while ((&obj->q2)->size > 1)
        {
            top = QueueFront(&obj->q2);
            QueuePop(&obj->q2);
            QueuePush(&obj->q1,top);
        }
        top = QueueFront(&obj->q2);
        QueuePop(&obj->q2);
        obj->size--;
        return top;
    }
 
}                                        

int myStackTop(MyStack* obj) {
    
    if ((&obj->q1)->size != 0)
        return (&obj->q1)->tail->data;
    else
        return (&obj->q2)->tail->data;

}

bool myStackEmpty(MyStack* obj) {
    return !obj->size;
}

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

3.leetcode.232 用栈实现队列

OJ链接：用栈实现队列

解题思路：同上一题的思路，本题也是用两个栈实现队列。其中s1用来push，s2用来pop和peek。与上一题不同的是，这次pop时，不用一直将s1的数据导入到s2中。而是当s2为空时再导入。

解题实战：

typedef int STDataType;

typedef struct Stack
{
	STDataType* a;  //动态开辟数组
	int capacity; //记录栈的容量大小
	int top; //记录栈顶的位置
}Stack;

//栈的初始化
void StackInit(Stack* ps);
//释放动态开辟的内存
void StackDestroy(Stack* ps);
//压栈
void StackPush(Stack* ps, STDataType data);
//出栈
void StackPop(Stack* ps);
//读取栈顶的元素
STDataType StackTop(Stack* ps);
//判断栈是否为空
bool StackEmpty(Stack* ps);
//栈存储的数据个数
int StackSize(Stack* ps);

void StackInit(Stack* ps)
{
	assert(ps);
	//初始化时，可附初值，也可置空
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

void StackDestroy(Stack* ps)
{
	assert(ps);
	//若并未对ps->a申请内存，则无需释放
	if (ps->capacity == 0)
		return;
	//释放
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

void StackPush(Stack* ps,STDataType data)
{
	assert(ps);
	//若容量大小等于数据个数，则说明栈已满，需扩容
	if (ps->capacity == ps->top)
	{
		//若为第一次扩容，则大小为4，否则每次扩大2倍
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		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] = data;
	ps->top++;
}

void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	//出栈
	ps->top--;
}

STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	//返回栈顶的数据
	return ps->a[ps->top - 1];
}

bool StackEmpty(Stack* ps)
{
	assert(ps);
	//返回top
	return ps->top == 0;
}

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

typedef struct {
    Stack s1; //用来push数据
    Stack s2; //用来pop和peek
} MyQueue;

MyQueue* myQueueCreate() {
    MyQueue* myqueue = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&myqueue->s1);
    StackInit(&myqueue->s2);
    return myqueue;
}

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

int myQueuePeek(MyQueue* obj) {
    //s2不为空时，不用再将s1的数据导入到s2
    if(StackEmpty(&obj->s2))
    {
        //将s1的数据倒着push到s2中
        while (!StackEmpty(&obj->s1))
        {
            STDataType top = StackTop(&obj->s1);
            StackPop(&obj->s1);
            StackPush(&obj->s2, top);
        }
    }
    //此时s2的数据是逆置的，所以栈顶的数据也就是队头的数据
    return StackTop(&obj->s2);

}

int myQueuePop(MyQueue* obj) {

    STDataType top= myQueuePeek(obj);
    //此时s2的数据是逆置的，pop s2栈顶的数据，也就是pop队头的数据
    StackPop(&obj->s2);
    return top;
}


bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->s1) && StackEmpty(&obj->s2);
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->s1);
    StackDestroy(&obj->s2);
    free(obj);
    obj = NULL;

4.leetcode.622 设计循环队列

OJ链接：设计循环队列

解题思路：循环队列与普通的队列就两点差别。

1.增加一个capacity来记录队列的容量

2.队尾与队头相连（称之为循环）

解题实战：

typedef int QDataType;

typedef struct QueueNode
{
	QDataType data; //存储的数据
	struct QueueNode* next; //记录下一个结点的位置
}QNode;

typedef struct {
    QNode* head;
    QNode* tail;
    int size;
    int capacity;
} MyCircularQueue;

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

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* tmp=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    tmp->head=NULL;
    tmp->tail=NULL;
    tmp->size=0;
    tmp->capacity=k;
    return tmp;
}

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

    QNode* newNode = (QNode*)malloc(sizeof(QNode));
	if (newNode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newNode->next = NULL;
	newNode->data = value;
	if (obj->size == 0)
	{
	    obj->head = obj->tail = newNode;
		obj->size++;

	}
	else
	{
		obj->tail->next = newNode;
		obj->tail = newNode;
        newNode->next=obj->head;
		obj->size++;
	}

    return true;
}

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

    QNode* cur=obj->head;
    obj->head=obj->head->next;
    obj->tail->next=obj->head;
    free(cur);
    obj->size--;
    return true;

}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;
    return obj->head->data;
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;
    return obj->tail->data;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return !obj->size;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->size==obj->capacity;
}

void myCircularQueueFree(MyCircularQueue* obj) {

    if(myCircularQueueIsEmpty(obj))
    {
        free(obj);
        return;
    }
    while(obj->head!=obj->tail)
    {
        QNode* cur=obj->head;
        obj->head=obj->head->next;
        free(cur);
    }
    free(obj->head);
    free(obj);
    obj=NULL;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/176346.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【C++】从0到1入门C++编程学习笔记 - 实战篇：职工管理系统

【C++】从0到1入门C++编程学习笔记 - 实战篇：职工管理系统

文章目录一、需求分析二、创建项目2.1 创建新项目2.2 添加文件三、创建管理类3.1 创建文件3.2 头文件实现3.3 源文件实现四、菜单功能4.1 添加成员函数4.2 菜单功能实现4.3 测试菜单功能五、退出功能5.1 提供功能接口5.2 实现退出功能5.3 测试功能六、创建职工类6.1 创建职工抽…
阅读更多...
虚拟机克隆两网卡冲突

虚拟机克隆两网卡冲突

常见网卡设置 vim /etc/sysconfig/network-scripts/ifcfg-ens33TYPEEthernet BOOTPROTOstatic DEFROUTEyes NAMEens33 UUID025f7880-7357-4148-ae5a-a629d597c133 DEVICEens33 ONBOOTyes DNS18.8.8.8 IPADDR 192.168.100.16 GATEWAY192.168.100.254 NETMASK255.255.255.0有的版…
阅读更多...
25/365 java 守护线程 线程同步 synchronized

25/365 java 守护线程 线程同步 synchronized

1.守护线程 线程分为守护线程和用户线程 ： daemon thread and non-daemon thread 虚拟机必须等待用户线程执行完毕，但无需等待守护线程执行完毕。 守护线程举例：垃圾回收线程，监控内存线程。 setDaemon(true):默认为false,默…
阅读更多...
【LeetCode:121. 买卖股票的最佳时机~~~动态规划】

【LeetCode:121. 买卖股票的最佳时机~~~动态规划】

题目描述 给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的…
阅读更多...
【微信小程序】文章点赞功能的实现

【微信小程序】文章点赞功能的实现

🏆今日学习目标：第二十期——文章点赞功能的实现 ✨个人主页：颜颜yan_的个人主页 ⏰预计时间：15分钟 🎉专栏系列：我的第一个微信小程序 文章目录前言效果图实现步骤总结前言 哈喽大家好，本期是…
阅读更多...
Unity简单几行代码让玩家水平移动更丝滑真实

Unity简单几行代码让玩家水平移动更丝滑真实

可以先来看看基础的移动代码，接收玩家的输入，然后赋予刚体速度。 但是这种写法存在几个问题，下面一一纠正。 首先，如果直接改变刚体的速度，那么可能会出现穿墙的问题。 而且没有一种从速度0到缓慢加速的过程&#xff…
阅读更多...
自定义Filter后,我的业务代码怎么被执行了多次？

自定义Filter后,我的业务代码怎么被执行了多次？

若要求构建的过滤器针对全局路径有效，且无任何特殊需求（主要针对 Servlet 3.0 的一些异步特性），则完全可直接使用 Filter 接口（或继承 Spring 对 Filter 接口的包装类 OncePerRequestFilter），并…
阅读更多...
分享130个ASP源码，总有一款适合您

分享130个ASP源码，总有一款适合您

ASP源码 分享130个ASP源码，总有一款适合您 下面是文件的名字，我放了一些图片，文章里不是所有的图主要是放不下...， 130个ASP源码下载链接：https://pan.baidu.com/s/13ZxaHPHdgorjGV1wWvx1WQ?pwd7z4p 提取码&#x…
阅读更多...
07_FreeRTOS任务调度器的挂起和恢复

07_FreeRTOS任务调度器的挂起和恢复

任务调度器的挂起和恢复 挂起任务调度器,调用此函数不需要关闭中断 使用格式示例: 1.与临界区不一样的是,挂起任务调度器,未关闭中断; 2.它仅仅是防止；饿任务之间的资源争夺,中断照样可以直接响应; 3.挂起调度器的方式,适合于临界区位于任务与任务之间;既不用去延…
阅读更多...
MySQL 8.0.31 集合操作INTERSECT和EXCEPT

MySQL 8.0.31 集合操作INTERSECT和EXCEPT

对于聚合的功能MySQL是都是默默的发展。在最新的8.0.31版本中提供对集合操作INTERSECT和EXCEPT。这样一来，集合操作功能基本圆满了。MySQL5.7.40版本是不支持这个集合的。 In this release MySQL adds support for the SQL standard INTERSECT and EXCEPT table op…
阅读更多...
Linux常用命令——ssh命令

Linux常用命令——ssh命令

在线Linux命令查询工具(http://www.lzltool.com/LinuxCommand) ssh openssh套件中的客户端连接工具 补充说明 ssh命令是openssh套件中的客户端连接工具，可以给予ssh加密协议实现安全的远程登录服务器。 语法 ssh(选项)(参数)选项 -1：强制使用ssh协…
阅读更多...
基于FPGA的时间数字转换(TDC)设计（四）

基于FPGA的时间数字转换(TDC)设计（四）

1. 基于IODELAY的TDC设计原理 在第一篇中讲过，基于FPGA开发的TDC常见的有直接计数法，多相位时钟采样法，抽头延迟线法等等。前面3篇讲解了基于多相位的TDC，接下来主要讲解基于抽头延迟线的方法。在Xilinx FPGA开发中，要实现抽头延迟线，主要由进位链(Carry4)和IODELAY模块…
阅读更多...
寒假题练——day（6）

寒假题练——day（6）

题目1： 有一种兔子，从出生后第3个月起每个月都生一只兔子， 小兔子长到第三个月后每个月又生一只兔子。 例子：假设一只兔子第3个月出生，那么它第5个月开始会每个月生一只兔子。 一月的时候有一只兔子，假如兔…
阅读更多...
检索方案优化

检索方案优化

文章目录 1. Flab框架概览2. Flab框架各个层在基金检索的具体应用2.1. 前置检查Check层2.2. 多路召回Recall层2.3. 结果集过滤2.3.1. 问财和我们召回结果的交集2.4. 排序Rank2.5. 缓存Cache2.6. 封装Assmeble1. Flab框架概览 Fly like a bird 寓意灵活 2. Flab框架各个层在基金…
阅读更多...
【Transformer】Attension梳理

【Transformer】Attension梳理

阅读更多...
2023年大年初一 —— 牛客网刷题经验分享~

2023年大年初一 —— 牛客网刷题经验分享~

2023年大年初一 —— 牛客网刷题经验分享~😎大年初一 —— 牛客网刷题经验分享~😎)前言🙌BC94 反向输出一个四位数 😊BC95 小乐乐与进制转换 😊BC96 [NOIP2015]金币😊BC97 回文对称数 😊总结撒花…
阅读更多...
pytorch 神经网络基础入门笔记【b站小土堆】

pytorch 神经网络基础入门笔记【b站小土堆】

文章目录python深度学习配置环境anacondapycharmpytorchpython学习中的两大法宝函数加载数据Tensorboard使用torchvision中的transformstensor数据类型transform该如何使用为什么我们需要Tensor类型更好的使用transformsToTensorNormalizeResizeComposeRandomCrop总结torchvisi…
阅读更多...
JVM快速入门学习笔记（三）

JVM快速入门学习笔记（三）

9. 栈 栈：8大基本类型对象引用 栈运行原理：栈帧 程序正在执行的方法，一定在栈的顶部 9.1 JVM数据区 先上一张Java虚拟机运行时数据区中堆、栈以及方法区存储数据的概要图，如下所示： 9.2 堆 堆是存储时的单位&…
阅读更多...
美团出品 | YOLOv6 v3.0 is Coming（超越YOLOv7、v8）

美团出品 | YOLOv6 v3.0 is Coming（超越YOLOv7、v8）

🚀🚀🚀美团出品 | YOLOv6 v3.0 is Coming ！！✨✨✨ 一、前言简介 🎄🎈 📚 代码地址：美团出品 | YOLOv6 3.0代码下载地址 📚 文章地址：https://a…
阅读更多...
四、python-pyecharts图表可视化(黑马程序猿-python学习记录)

四、python-pyecharts图表可视化(黑马程序猿-python学习记录)

黑马程序猿的python学习视频：https://www.bilibili.com/video/BV1qW4y1a7fU/ 目录 1. 官网链接 2. 下载pyecharts 3. 编写一个折线图 4. 隐藏线段上的数据 5. 绘制柱状图 6. 柱状图的xy轴反转 7. 柱状图设置提示在最右边 8. 时间柱状图 9. 时间柱状图设置颜色主题 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023