C语言基础——⑩③数据结构——②栈和队列

一、栈(Stack)

1、基本概念

栈是一种逻辑结构，是特殊的线性表。特殊在：

  • 只能在固定的一端操作

只要满足上述条件，那么这种特殊的线性表就会呈现一种“后进先出”的逻辑，这种逻辑就被称为栈。栈 在生活中到处可见，比如堆叠的盘子、电梯中的人们、嵌套函数的参数等等。

由于约定了只能在线性表固定的一端进行操作，于是给栈这种特殊的线性表的“插入”、“删除”，另起了 下面这些特定的名称：

  • 栈顶：可以进行插入删除的一端；
  • 栈底：栈顶的对端；
  • 入栈：将节点插入栈顶之上，也称为压栈，函数名通常为push()；
  • 出栈：将节点从栈顶剔除，也称为弹栈，函数名通常为pop()；
  • 取栈顶：取得栈顶元素，但不出栈，函数名通常为top()

基于这种固定一端操作的简单约定，栈获得了“后进先出”的基本特性，如下图所示，最后一个放入的元素，最先被拿出来：

2、存储形式

栈只是一种数据逻辑，如何将数据存储于内存则是另一回事。一般而言，可以采用顺序存储形成顺序栈，或采用链式存储形成链式栈。

1.顺序栈（sequenceStack）

顺序存储意味着开辟一块连续的内存来存储数据节点，一般而言，管理栈数据除了需要一块连续的 内存之外，还需要记录栈的总容量、当前栈的元素个数、当前栈顶元素位置，如果有多线程还需要 配互斥锁和信号量等信息，为了便于管理，通常将这些信息统一于在一个管理结构体之中：

// 顺序栈节点
struct seqStack
{datatype *data; // 顺序栈入口int size;       // 顺序栈总容量int top;        // 顺序栈栈顶元素下标
};

2.链式栈(linkStack)

链式栈的组织形式与链表无异，只不过插入删除被约束在固定的一端。为了便于操作，通常也会创 建所谓管理结构体，用来存储栈顶指针、栈元素个数等信息：

// 链式栈节点
typedef struct node
{datatype data;struct node *next;
}node;
// 链式栈管理结构体
struct linkStack
{node *top; // 链式栈栈顶指针int  size; // 链式栈当前元素个数
};

3、完整代码

  • 顺序栈(sequenceStack)

  1. sstack.h
    #ifndef __SSTACK_H
#define __SSTACK_H
// 数据类型
typedef int DATA;
// 顺序栈结构体
typedef  struct
{DATA      *pData; // 栈中元素的地址int         size; // 栈的总容量int         top;  // 栈顶元素下标
}SeqStack;
// 初始化栈
int SStack_init(SeqStack *s, int num);
// 判断栈是否已满
int SStack_isfull(SeqStack *st);
// 判断栈是否为空
int SStack_isempty(SeqStack *st);
// 入栈/压栈
int SStack_push(SeqStack *st,DATA data);
// 出栈/弹栈
int SStack_pop(SeqStack *st,DATA *data);
// 回收栈
int SStack_free(SeqStack *st);
#endif
  2. sstack.c
    #include <stdlib.h>
#include "sstack.h"
// 初始化栈
int SStack_init(SeqStack* s,int num)
{s -> pData = (DATA*)calloc(sizeof(DATA),num);if(s -> pData == NULL)return -1;s -> size  = num ;s -> top   = -1;return 0;
}
// 判断栈是否已满
int SStack_isfull(SeqStack *st)
{return st -> top + 1 == st -> size;
}
// 判断栈是否为空
int SStack_isempty(SeqStack *st)
{return st -> top == -1;
}
// 压栈/入栈
int SStack_push(SeqStack *st,DATA data)
{if(SStack_isfull(st))return -1;st -> top++;st -> pData[st -> top] = data;return 0;
}
// 出栈/弹栈
int SStack_pop(SeqStack *st,DATA *data)
{if(SStack_isempty(st))return -1;*data = st -> pData[st -> top];st -> top--;return 0;
}
// 回收栈
int SStack_free(SeqStack *st)
{if(st -> pData){free(st->pData);st -> pData = NULL;}st -> top = -1;  
}
  3. sstack_main.c
    #include "sstack.h"
#include <stdio.h>
int main(void)
{SeqStack  st;SStack_init(&st,10);register int i = 1;for(; i <=10; i++)SStack_push(&st,i);if(-1 == SStack_push(&st,1024))fprintf(stderr,"满栈,插入失败\n");while(!SStack_isempty(&st)){DATA   data = 0;SStack_pop(&st,&data);printf("%4d",data);         }printf("\n");SStack_free(&st);return 0;  
}

【课堂练习1】

使用顺序栈，接收键盘的输入，实现如下功能：

1. 输入数字时，依次入栈。

2. 输入字母时，依次出栈。

3. 每次入栈或者出栈，都将顺序栈中的各个元素输出出来。

  • 完整代码（链式栈(linkStack)）

  1. linkstack.h
    #ifndef __LINKSTACK_H
#define __LINKSTACK_H
// 数据类型
typedef   int   DATA;
// 链式栈节点
typedef   struct  _node
{DATA       data; // 数据struct _node *next; // 指向下一个栈的节点
}NODE;
// 链式栈管理结构体
typedef  struct
{NODE     *pHead;// 链式栈栈顶指针int       size; // 链式栈当前元素个数int       num;
}LinkStack;
// 初始化链式栈
int LStack_init(LinkStack *s, int num);
// 判断栈是否已满
int LStack_isfull(LinkStack *st);
// 判断栈是否为空
int LStack_isempty(LinkStack *st);
// 压栈/入栈
int LStack_push(LinkStack *st,DATA data);
// 弹栈/出栈
int LStack_pop(LinkStack *st,DATA *data);
// 回收栈
int LStack_free(LinkStack *st);
#endif
  2. linkstack.c
    #include "linkstack.h"
#include <stdio.h>
#include <stdlib.h>
// 初始化栈
int LStack_init(LinkStack *st, int num)
{st -> pHead = NULL;st -> size  = num;st -> num   = 0;return 0 ;
}
// 判断栈是否已满
int LStack_isfull(LinkStack *st)
{return st -> num == st -> size;
}
// 判断栈是否为空
int LStack_isempty(LinkStack *st)
{return st -> num == 0;
}
// 入栈
int LStack_push(LinkStack *st,DATA data)
{if(LStack_isfull(st))return -1;NODE* p = (NODE*)malloc(sizeof(NODE));if(!p)return -1;p -> data   = data;p -> next   = st -> pHead;st -> pHead = p;(st -> num)++;return 0;
}
// 出栈
int LStack_pop(LinkStack *st,DATA *data)
{if(LStack_isempty(st))return -1;NODE* p = st -> pHead;if(!p)return -1;*data = p -> data;st -> pHead = p -> next;free(p);(st -> num)--;return 0;
}
// 回收栈
int LStack_free(LinkStack *st)
{NODE* p = st -> pHead, *q = NULL;while(p){q  = p;p  = p -> next;free(q);       }st -> pHead = NULL;st -> num   = 0;return 0;
}
  3. linkstack_main.c
    #include "linkstack.h"
#include <stdio.h>
int main(void)
{LinkStack  st;LStack_init(&st,10);register int i = 1;for(; i <= 10; i++)LStack_push(&st,i);if(-1 == LStack_push(&st,1024))fprintf(stderr,"满栈,插入失败\n");while(!LStack_isempty(&st)){DATA   data = 0;LStack_pop(&st,&data);printf("%4d",data);         }printf("\n");LStack_free(&st);return 0;  
}

【课堂练习2】

使用链式栈，实现十进制转八进制：键盘输入一个十进制数，经过链式栈的相关算法，输出八进制 数。

代码：

二、队列(queue)

1、基本概念

队列是一种逻辑结构，是一种 特殊的线性表。特殊在： 只能在固定的两端操作线性表 只要满足上述条件，那么这种特殊的线性表就会呈现一种“先进先出”的逻辑，这种逻辑就被称为队列。

队列本质上，是从一端进，另一端出，为了保证跟生活的认知一致，我们建议把进的一端叫做队尾，出的一端叫做对头。

由于约定了只能在线性表固定的两端进行操作，于是给队列这种特殊的线性表的插入删除，起个特殊的名称：

  • 队头：可以删除节点的一端；
  • 队尾：可以插入节点的一端；
  • 入队：将节点插入到队尾之后，函数名通常为enQueue()；
  • 出队：将队头节点从队列中剔除，函数名通常为outQueue()；
  • 取队头：取得队头元素，但不出队，函数名通常为front()。

由于这种固定两端操作的简单约定，队列获得了“先进先出”的基本特性，如下图所示：

2、顺序存储的队列：循环队列(sequenceQueue)

与其他的逻辑结构类似，队列可以采用顺序存储形成循环队列，也可以采用链式存储形成链式队列。 顺序存储的队列之所以被称为循环队列，是因为可以利用更新队头队尾的下标信息，来循环地利用整个数组，出队入队时也不必移动当中的数据。循环队列示意图如下所示：

从上述动图中可以观察到，需要牺牲至少数组中的一个存储位置，来区分循环队列中的满队和空队。 满队和空队的约定如下：

  • 当front与rear相等时，队列为空；
  • 当rear循环加一与front相等时，队列为满；

与其他数据结构一样，管理循环队列除了需要一块连续的内存之外，还需要记录队列的总容量、当前 队列的元素个数、当前队头、队尾元素位置，如果有多线程还需要配互斥锁和信号量等信息，为了便于管理，通常将这些信息统一于在一个管理结构体之中：

typedef   int   DATA;
typedef  struct
{DATA      *pData; // 队列入口int         size;   // 队列总容量int         head;   // 队列队头元素下标int         tail;   // 队列队尾元素下标
}SQueue;

3、完整代码（顺序-循环队列）

  • squeue.h

    #ifndef __SQUEUE_H
#define __SQUEUE_H
typedef   int   DATA;
typedef  struct
{DATA      *pData; // 队列入口int         size;   // 队列总容量int         head;   // 队列队头元素下标int         tail;   // 队列队尾元素下标
}SQueue;
// 初始化队列
int SQ_init(SQueue *q, int num);
// 判断队列是否已满
int SQ_isfull(SQueue *q);
// 判断队列是否为空
int SQ_isempty(SQueue *q);
// 入队
int SQ_push(SQueue *q,DATA data);
// 出队
int SQ_pop(SQueue *q,DATA *data);
// 回收队
int SQ_free(SQueue *q);
#endif

  • squeue.c

    #include <stdlib.h>
#include "squeue.h"
// 初始化队列
int SQ_init(SQueue* q,int num)
{q -> pData = (DATA*)calloc(sizeof(DATA),num);if(q -> pData == NULL)return -1;q -> size  = num ;q -> head  = q -> tail = 0;return 0;
}
// 判断队列是否已满
int SQ_isfull(SQueue *q)
{return (q -> tail + 1) % q -> size  == q -> head;
}
// 判断队列是否为空
int SQ_isempty(SQueue *q)
{return q -> tail  == q -> head;
}
// 出队
int SQ_push(SQueue *st,DATA data)
{if(SQ_isfull(st))return -1;st -> pData[st -> tail] = data;st -> tail = (st -> tail+1) % st -> size;return 0;
}
// 入队
int SQ_pop(SQueue *st,DATA *data)
{if(SQ_isempty(st))return -1;*data = st -> pData[st -> head];st -> head = (st -> head+1) % st -> size;return 0;
}
// 回收队列
int SQ_free(SQueue *st)
{if(st -> pData){free(st->pData);st -> pData = NULL;}st -> head = st -> tail  = 0;  
}

注意： 循环队列中，需要牺牲一个存储位置来区分空队和满队

【课堂练习3】

构建一个顺序存储的循环队列，当用户输入数字时，将数字入队，当用户输入字母时，将队头元素出队。每次操作队列之后，将队列中的元素显示出来。

4、链式存储的队列：链式队列(linkQueue)

链式队列的组织形式与链表无异，只不过插入删除被约束在固定的两端。为了便于操作，通常也会创建所谓管理结构体，用来存储队头指针、队尾指针、队列元素个数等信息：

从上图可以看到，链式队列主要控制队头和队尾，由于管理结构体中保存了当前队列元素个数size，因 此可以不必设计链表的头节点，初始化空队列时只需要让队头队尾指针同时指向空即可。

以下是队列链表节点设计和管理结构体设计的示例代码：

typedef  int  DATA;
// 链式队列节点
typedef struct _node
{DATA        data;struct _node  *next;
}NODE/*,*PNODE*/;// 链式队列管理结构体
typedef struct
{NODE     *pHead; // 队头指针NODE     *pTail; // 队尾指针int       size ; // 队列当前元素个数int       num ;
}LinkQueue;

5、完整代码（链式队列(linkQueue)）

当进入新数据时，创建新节点

  • linkQueue.h

    #ifndef __LINKQUEUE_H
#define __LINKQUEUE_H
typedef  int  DATA;
// 链式队列节点
typedef struct _node
{DATA        data;struct _node  *next;
}NODE/*,*PNODE*/;
// 链式队列管理结构体
typedef struct
{NODE     *pHead; // 队头指针NODE     *pTail; // 队尾指针int       size ; // 队列当前元素个数int       num ;
}LinkQueue;
void LQ_init(LinkQueue *q,int sz);
int  LQ_isfull(LinkQueue *q);
int  LQ_isempty(LinkQueue *q);
int  LQ_push(LinkQueue *q,DATA data);
int  LQ_pop(LinkQueue *q,DATA *data);
int LQ_free(LinkQueue *q);
#endif

  • linkQueue.c

    #include "LinkQueue.h"
#include <stdlib.h>
void LQ_init(LinkQueue *q,int sz)
{q -> pHead = q -> pTail = NULL;q -> size  = sz;q -> num   = 0;
}
int  LQ_isfull(LinkQueue *q)
{return q -> num == q -> size;
}
int  LQ_isempty(LinkQueue *q)
{return q -> num == 0;
}
int  LQ_push(LinkQueue *q,DATA data)
{if(LQ_isfull(q))return -1;NODE* pNew = (NODE*)malloc(sizeof(NODE));if(!pNew)return -1;pNew -> data  = data;pNew -> next  = NULL;if(!(q -> pTail))q -> pHead = q -> pTail = pNew;else{       q -> pTail -> next  = pNew;q -> pTail = pNew;}q -> num ++;return 0;
}
int  LQ_pop(LinkQueue *q,DATA *data)
{if(LQ_isempty(q))return -1;NODE* p = q -> pHead;*data  = p -> data;if(p == q -> pTail)q -> pHead = q -> pTail = NULL;else     q -> pHead = p -> next;free(p);q -> num --;return 0;
}
int LQ_free(LinkQueue *queue)
{NODE* p = queue -> pHead, *q = NULL;while(p){q  = p;p  = p -> next;free(q);}queue -> pHead = queue -> pTail = NULL;queue -> num   = 0;return 0;
}

  • linkQueue_main.c

    #include "LinkQueue.h"
#include <stdio.h>
int main(void)
{LinkQueue    queue;LQ_init(&queue,10);register  int i = 1;    for(; i <= 10 ; i++) LQ_push(&queue, i);if( -1 == LQ_push(&queue,1024))fprintf(stderr,"满队,入队失败!\n");while(!LQ_isempty(&queue)){DATA   data;LQ_pop(&queue,&data);printf("%4d",data);}printf("\n");LQ_free(&queue);return 0; 
}

【课堂练习4】

构建一个链式队列，当用户输入数字时，将数字入队，当用户输入字母时，将队头元素出队。每次操作队列之后，将队列中的元素显示出来。

章节作业

（栈的基本操作）

【1】编程实现功能：将键盘输入的十进制数，转换为十六进制输出。

（栈的基本操作）（选做）

【2】编程实现汉诺塔游戏。

（栈的基本操作）（选做）

【3】面试题

（队列的基本操作）（选做）

【4】蜗牛在制定今天的旅游计划，有 nn 个景点可选，它已经把这些景点按照顺路游览的顺序排成一排了，每个地方有相应的景观标号，这里用一个整数表示，相同的标号意味着相同的景观。 蜗牛希望选取连续的一段景点，还要选出来的每一个景点的景观都不同，问它最多能选出多少个景点进行旅游。

提示：

假设景点的景观标号是： 6 2 8 2 6

那么蜗牛可选的最长不重复的连续景点数是3，即前三个6 2 8，或后三个8 2 6

v图像 小部件

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

为什么企业需要数据目录？

为什么企业需要数据目录？

想象一下&#xff0c;如果在没有目录系统的庞大图书馆里寻找一本特定的书&#xff0c;你可能会耗费无数个小时搜索&#xff0c;但最终却一无所获。 同理&#xff0c;企业的数据如果没有一个组织良好、易于搜索的系统&#xff0c;也无法充分发挥其潜力。企业数据目录能够简化这一…
阅读更多...
Kafka 基础与架构理解

Kafka 基础与架构理解

目录 前言 Kafka 基础概念 消息队列简介&#xff1a;Kafka 与传统消息队列&#xff08;如 RabbitMQ、ActiveMQ&#xff09;的对比 Kafka 的组件 Kafka 的工作原理&#xff1a;消息的生产、分发、消费流程 Kafka 系统架构 Kafka 的分布式架构设计 Leader-Follower 机制与…
阅读更多...
进击J6：ResNeXt-50实战

进击J6：ResNeXt-50实战

&#x1f368; 本文为&#x1f517;365天深度学习训练营 中的学习记录博客&#x1f356; 原作者&#xff1a;K同学啊 一、实验目的&#xff1a; 阅读ResNeXt论文&#xff0c;了解作者的构建思路对比之前介绍的ResNet50V2、DenseNet算法使用ResNeXt-50算法完成猴痘病识别 二、实…
阅读更多...
jmeter之仅一次控制器

jmeter之仅一次控制器

仅一次控制器作用&#xff1a; 不管线程组设置多少次循环&#xff0c;它下面的组件都只会执行一次 Tips&#xff1a;很多情况下需要登录才能访问其他接口&#xff0c;比如&#xff1a;商品列表、添加商品到购物车、购物车列表等&#xff0c;在多场景下&#xff0c;登录只需要…
阅读更多...
【EJB】会话Bean（Session Bean）

【EJB】会话Bean（Session Bean）

单例会话****bean在每个应用程序中实例化一次&#xff0c;并存在于应用程序的生命周期中。单例会话bean是为单个企业bean实例在客户端之间共享和并发访问的环境而设计的。 单例会话Bean提供了与无状态会话Bean相似的功能&#xff0c;但与它们不同&#xff0c;因为每个应用程序…
阅读更多...
【CanMV K230 AI视觉】人脸关键部位

【CanMV K230 AI视觉】人脸关键部位

【CanMV K230 AI视觉】人脸关键部位 人脸关键部位 &#xff08;动态测试效果可以去下面网站自己看。&#xff09; B站视频链接&#xff1a;已做成合集 抖音链接&#xff1a;已做成合集 人脸关键部位 人脸关键部位检测&#xff0c;主要检测脸部轮廓、眉毛、眼睛、鼻子和嘴巴&a…
阅读更多...
【Kubernetes】K8s 的鉴权管理（二）：基于属性 / 节点 / Webhook 的访问控制

【Kubernetes】K8s 的鉴权管理（二）：基于属性 / 节点 / Webhook 的访问控制

K8s 的鉴权管理&#xff08;二&#xff09;&#xff1a;基于属性 / 节点 / Webhook 的访问控制 1.基于属性的访问控制&#xff08;ABAC 鉴权&#xff09;2.基于节点的访问控制&#xff08;node 鉴权&#xff09;2.1 读取操作2.2 写入操作 3.基于 Webhook 的访问控制3.1 基于 We…
阅读更多...
什么是 Grafana？

什么是 Grafana？

什么是 Grafana&#xff1f; Grafana 是一个功能强大的开源平台&#xff0c;用于创建、查看、查询和分析来自多个来源的数据。通过可视化仪表盘&#xff08;Dashboard&#xff09;&#xff0c;它能够帮助用户监控实时数据、生成历史报告&#xff0c;甚至进行预测分析。Grafana…
阅读更多...
深入解读Docker核心原理：Cgroups资源限制机制详解

深入解读Docker核心原理：Cgroups资源限制机制详解

在容器化技术中&#xff0c;除了资源的隔离&#xff0c;如何有效地控制和分配系统资源同样至关重要。Cgroups&#xff08;Control Groups&#xff09; 是Linux内核提供的一个强大机制&#xff0c;允许限制、监控和隔离进程组的系统资源使用情况。Cgroups是Docker实现容器资源限…
阅读更多...
ffmpeg实现视频的合成与分割

ffmpeg实现视频的合成与分割

视频合成与分割程序使用 作者开发了一款软件&#xff0c;可以实现对视频的合成和分割&#xff0c;界面如下&#xff1a; 播放时&#xff0c;可以选择多个视频源&#xff1b;在选中“保存视频”情况下&#xff0c;会将多个视频源合成一个视频。如果只取一个视频源中一段视频…
阅读更多...
初识爬虫1

初识爬虫1

学习路线&#xff1a;爬虫基础知识-requests模块-数据提取-selenium-反爬与反反爬-MongoDB数据库-scrapy-appium。 对应视频链接(百度网盘)&#xff1a;正在整理中 爬虫基础知识&#xff1a; 1.爬虫的概念 总结&#xff1a;模拟浏览器&#xff0c;发送请求&#xff0c;获取…
阅读更多...
Minimax-秋招正式批-面经(SQL相关)

Minimax-秋招正式批-面经(SQL相关)

1. 谈谈对聚簇索引的理解 聚簇索引 InnoDB通过主键聚集数据&#xff0c;如果没有定义主键&#xff0c;InnoDB会选择非空的唯一索引代替。如果没有这样的索引&#xff0c;InnoDB会隐式定义一个主键来作为聚簇索引聚簇索引就是按照每张表的主键构造一颗B树&#xff0c;同时叶子…
阅读更多...
挖耳勺可以和别人共用吗？口碑好的可视耳勺！

挖耳勺可以和别人共用吗？口碑好的可视耳勺！

人体分泌的耳垢会有细菌&#xff0c;如果与别人共用挖耳勺很有可能会交叉感染&#xff0c;所以一般建议自己有专用的挖耳勺。小编可以给大家分享一款超好用又能实现一人一用的挖耳勺--可视挖耳勺&#xff0c;它有着高清内窥镜可以进入耳道实时查看情况&#xff0c;并且耳勺头采…
阅读更多...
Unity人工智能开发学习心得

Unity人工智能开发学习心得

在Unity中进行人工智能研究与应用主要集中在几个关键领域&#xff0c;包括使用Unity ML-Agents插件进行强化学习、利用神经网络技术和深度学习技术训练AI&#xff0c;以及基于行为树技术设计游戏人工智能。 ‌使用Unity ML-Agents插件进行强化学习‌&#xff1a;Unity ML-Agent…
阅读更多...
浏览器百科：网页存储篇-IndexedDB介绍（十）

浏览器百科：网页存储篇-IndexedDB介绍（十）

1.引言 在现代网页开发中&#xff0c;数据存储需求日益增多和复杂&#xff0c;传统的客户端存储技术如localStorage和sessionStorage已难以满足大型数据的存储和管理需求。为了解决这一问题&#xff0c;HTML5 引入了 IndexedDB&#xff0c;在本篇《浏览器百科&#xff1a;网页…
阅读更多...
Debug-027-el-tooltip组件的使用及注意事项

Debug-027-el-tooltip组件的使用及注意事项

前言&#xff1a; 这两天&#xff0c;碰到这个饿了么的el-tooltip比较多。这个组件使用起来也挺简单的&#xff0c;常用于展示鼠标 hover 时的提示信息。但是有一些小点需要注意。这里不再机械化的介绍文档&#xff0c;不熟悉的话可以先看一下&#xff1a; https://element-pl…
阅读更多...
Linux 硬件学习 s3c2440 arm920t蜂鸣器

Linux 硬件学习 s3c2440 arm920t蜂鸣器

1.查找手册时钟图&#xff0c;输入12m想要通过pll得到400m的信号 2.对比pll值&#xff0c;找到最近的为405&#xff0c;得到pll中mdiv为127&#xff0c;pdiv为2&#xff0c;sdiv为1 3.想要得到fclk400&#xff0c;hclk100&#xff0c;pclk50&#xff0c;对比分频比例&#xff0…
阅读更多...
jmeter执行python脚本，python脚本的Faker库

jmeter执行python脚本，python脚本的Faker库

jmeter安装 jython的插件jar包 通过如下地址下载jython-standalone-XXX.jar包并放到jmeter的XXX\lib\ext目录下面 Downloads | JythonThe Python runtime on the JVMhttps://www.jython.org/download.html 重启jmeter在JSR223中找到jython可以编写python代码执行 python造数据…
阅读更多...
MySQL：运维管理-主从复制

MySQL：运维管理-主从复制

目录 一、主从复制的概述二、主从复制的工作原理三、搭建主从复制的结构3.1 环境准备3.2 搭建配置&#xff08;主库配置&#xff09;3.3 搭建配置&#xff08;从库配置&#xff09;3.4 测试 一、主从复制的概述 主从复制是指将主数据库中的DDL和DML操作的二进制文件保存到本地&…
阅读更多...
小间距LED显示屏的模组与箱体参数

小间距LED显示屏的模组与箱体参数

随着显示技术的发展&#xff0c;小间距LED显示屏因其高清晰度和高亮度而越来越受到市场的欢迎。然而&#xff0c;对于许多用户来说&#xff0c;如何理解和选择小间距LED显示屏的参数可能是一个挑战。本文将详细介绍小间距LED显示屏的两大核心参数&#xff1a;模组参数和箱体参数…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023