数据结构之栈与队列

一.栈

1.定义：一种线性表，只允许在固定的一端进行删除和插入数据的操作，该端叫栈底，另一端叫栈顶

2.特点：先进后出

注：栈中元素出栈是一对多的(他虽然满足先进后出但是我们可以在pop数据前先获取栈顶元素并打印再pop，这样就可能改变数据在屏幕上出现的顺序)

3.思路：可以用数组实现，也可以用链表实现

数组实现更简单，链表实现较为复杂，下面小编将从两方面解释不选择链表实现的原因

1>若选择单链表，在进行删除操作时，我们不好解决栈顶先前移一位的问题

2>若选择双向链表，将占用过多的内存

4.代码实现(以数组实现栈为例)：

(1)栈的结构体定义：包含数组指针，栈顶的位置，有效空间容量

typedef int STDatatype;
typedef struct Stack
{STDatatype* arr;int top;//栈顶int capacity;//有效空间容量
}ST;

(2)栈的初始化：将栈顶初始化为0：表示栈顶指向最后一个数据的下一个

                          将栈顶初始化为-1：表示栈顶指向最后一个数据所在位置

//栈的初始化
void STInit(ST* ps)
{assert(ps);ps->arr = NULL;//top指向栈顶后的一个元素,此时top等值于有效数据个数ps->top = 0;ps->capacity = 0;
}

(3)栈的销毁

//栈的销毁
void STDestory(ST* ps)
{assert(ps);free(ps->arr);ps->arr = NULL;ps->capacity = ps->top = 0;
}

(4)插入数据/入栈：先判断是否需要增容，再插入数据

//入栈
void STPush(ST* ps, STDatatype x)
{assert(ps);//判断是否需要增容if (ps->top == ps->capacity){int newcapacity = ps->capacity * 2==0 ? 4 : ps->capacity*2;STDatatype* tmp = (STDatatype*)realloc(ps->arr, sizeof(STDatatype) * newcapacity);if (tmp == NULL){perror("realloc fail");return;}ps->arr = tmp;ps->capacity = newcapacity;}ps->arr[ps->top] = x;ps->top++;
}

(5)删除数据/出栈：先判断数组是否为空，再将top--即完成删除

//出栈
void STPop(ST* ps)
{assert(ps);assert(ps->top > 0);ps->top--;
}

(6)获取栈顶元素

//获取栈顶数据
STDatatype STTop(ST* ps)
{assert(ps);return ps->arr[ps->top-1];
}

(7)判断栈是否为空：若top==0则为空

//判断栈是否为空
bool STEmpty(ST* ps)
{assert(ps);return ps->top == 0;
}

(8)栈中有效数据个数

//栈的有效数据个数
int STSize(ST* ps)
{assert(ps);return ps->top;
}

二.队列

1.定义：一种线性表，只允许在一端(队尾)进行数据插入，在另一端(队头)进行数据删除

2.特点：先进先出

注：队列的数据出队列时是一对一的

3.思路：可以用数组实现，也可以用链表实现 

单链表实现更简单，数组实现较为复杂，是因为在使用数组实现时，进行删除数据不好记录下一次该删除数据的位置

4.代码实现(以单链表实现队列为例)：

(1)队列的节点定义：指向下一个节点的指针，存储数据的数值

    队列的结构体定义：队列的头指针，尾指针，队列有效数据的个数

typedef int QueueDataType;typedef struct QueueNode
{QueueDataType val;struct QueueNode* next;
}QNode;typedef struct Queue
{QNode* head;QNode* tail;int size;
}Queue;

(2)队列的初始化

//队列的初始化
void QueueInit(Queue* pq)
{assert(pq);pq->head = NULL;pq->tail = NULL;pq->size = 0;
}

(3)队列的销毁：先逐个销毁队列的节点，再销毁队列

//队列的销毁
void QueueDestory(Queue* pq)
{assert(pq);QNode* cur = pq->head;while (cur){QNode* Next = cur->next;free(cur);cur = Next;}pq->head = NULL;pq->tail = NULL;pq->size = 0;
}

(4)插入数据：为该数据开辟一个新节点，若原队列中有数据则让尾指针向后走一步，若无则头尾    指针均指向该新节点

//队尾入数据
void QueuePush(Queue* pq, QueueDataType x)
{//开辟一个新节点QNode* node = (QNode*)malloc(sizeof(QNode));if (node == NULL){perror("malloc fail");return;}node->val = x;node->next = NULL;//队列中没有节点if (pq->tail == NULL){pq->head = node;pq->tail = node;}else{pq->tail->next = node;pq->tail = node;}pq->size++;
}

(5)删除数据：删除头指针指向的节点，并让头指针向后走一步，若只有一个节点删除后需将尾指针置空

//队头出数据
void QueuePop(Queue* pq)
{assert(pq);assert(pq->size != 0);QNode* next = pq->head->next;free(pq->head);pq->head = next;if (pq->head == NULL){pq->tail = NULL;}pq->size--;
}

(6)获取队头元素

//获取队头数据
QueueDataType QueueFront(Queue* pq)
{assert(pq);return pq->head->val;
}

(7)获取队尾元素

//获取队尾数据
QueueDataType QueueBack(Queue* pq)
{assert(pq);return pq->tail->val;
}

(8)判断队列是否为空

//判断队列是否为空
bool QueueEmpty(Queue* pq)
{assert(pq);return pq->size == 0;
}

(9)队列的大小

//获取队列有效数据个数
int QueueSize(Queue* pq)
{assert(pq);return pq->size;
}

三.栈与队列的相互转化

1.用栈实现队列

. - 力扣（LeetCode）

(1)思路：栈：先进后出，队列：先进先出

               创建两个栈实现队列中数据的删除

(2)解题方法：

1>自己实现栈

2>定义一个队列结构体包含两个栈

3>队列的创建：为队列结构体malloc一块空间，防止出函数时结构体被销毁

4>队列的销毁：先销毁两个栈，再销毁队列

5>队尾插数据：当两栈均为空栈时：随便在哪个空栈的栈顶插入数据均可

                          当有一个栈不为空时：在非空栈的栈顶插入数据

6>队头删数据：将非空栈的前size-1个数据导入空栈中，再删除队头的数据。此时对下次删除来说栈中数据顺序是错乱的，故还需要将原空栈的数据导回原非空栈中。

7>判断队列为空：当两个栈均为空时，队列为空

8>获取队尾数据：即非空栈的栈顶数据

(3)代码实现：

typedef int STDatatype;
typedef struct Stack
{STDatatype* arr;int top;//栈顶int capacity;//有效空间容量
}ST;//栈的初始化
void STInit(ST* ps);//栈的销毁
void STDestory(ST* ps);//入栈
void STPush(ST* ps, STDatatype x);//出栈
void STPop(ST* ps);//获取栈顶数据
STDatatype STTop(ST* ps);//判断栈是否为空
bool STEmpty(ST* ps);//栈的有效数据个数
int STSize(ST* ps);//栈的初始化
void STInit(ST* ps)
{assert(ps);ps->arr = NULL;//top指向栈顶后的一个元素,此时top等值于有效数据个数ps->top = 0;ps->capacity = 0;
}//栈的销毁
void STDestory(ST* ps)
{assert(ps);free(ps->arr);ps->arr = NULL;ps->capacity = ps->top = 0;
}//入栈
void STPush(ST* ps, STDatatype x)
{assert(ps);//判断是否需要增容if (ps->top == ps->capacity){int newcapacity = ps->capacity * 2==0 ? 4 : ps->capacity*2;STDatatype* tmp = (STDatatype*)realloc(ps->arr, sizeof(STDatatype) * newcapacity);if (tmp == NULL){perror("realloc fail");return;}ps->arr = tmp;ps->capacity = newcapacity;}ps->arr[ps->top] = x;ps->top++;
}//出栈
void STPop(ST* ps)
{assert(ps);assert(ps->top > 0);ps->top--;
}//获取栈顶数据
STDatatype STTop(ST* ps)
{assert(ps);return ps->arr[ps->top-1];
}//判断栈是否为空
bool STEmpty(ST* ps)
{assert(ps);return ps->top == 0;
}//栈的有效数据个数
int STSize(ST* ps)
{assert(ps);return ps->top;
}typedef struct {ST st1;ST st2;
} MyQueue;MyQueue* myQueueCreate() {MyQueue* pq=(MyQueue*)malloc(sizeof(MyQueue));STInit(&(pq->st1));STInit(&(pq->st2));return pq;
}void myQueuePush(MyQueue* obj, int x) {assert(obj);if(!STEmpty(&(obj->st1))){STPush(&(obj->st1),x);}else{STPush(&(obj->st2),x);}}int myQueuePop(MyQueue* obj) {assert(obj);ST* empty=&(obj->st1);ST* noempty=&(obj->st2);if(!STEmpty(&(obj->st1))){empty=&(obj->st2);noempty=&(obj->st1);}while(STSize(noempty)>1){STPush(empty,STTop(noempty));STPop(noempty);}STDatatype ret=STTop(noempty);STPop(noempty);//将noempty的数据导回empty,保证下次pop时数据顺序while(STSize(empty)>0){STPush(noempty,STTop(empty));STPop(empty);}return ret;
}int myQueuePeek(MyQueue* obj) {if(!STEmpty(&(obj->st1))){return obj->st1.arr[0];}else{return obj->st2.arr[0];}
}bool myQueueEmpty(MyQueue* obj) {return STEmpty(&(obj->st1)) && STEmpty(&(obj->st2));
}void myQueueFree(MyQueue* obj) {assert(obj);STDestory(&(obj->st1));STDestory(&(obj->st2));free(obj);obj=NULL;
}

2.用队列实现栈

. - 力扣（LeetCode）

(1)思路：栈：先进后出，队列：先进先出

               创建两个队列实现栈中数据的删除

(2)解题方法：

1>自己实现队列

2>定义一个栈结构体包含两个队列

3>栈的创建：为栈结构体malloc一块空间，防止出函数时结构体被销毁

4>栈的销毁：先销毁两个队列，再销毁栈

5>入栈：当两队列均为空队列时：随便在哪个空队列的队尾插入数据均可

                          当有一个队列不为空时：在非空队列的队尾插入数据

6>出栈：将非空队列的前size-1个数据导入空队列中，再删除栈顶元素。

7>判断栈为空：当两个队列均为空时，栈为空

8>获取栈顶数据：即非空队列的队尾元素

(3)代码实现：

typedef int QueueDataType;typedef struct QueueNode
{QueueDataType val;struct QueueNode* next;
}QNode;typedef struct Queue
{QNode* head;QNode* tail;int size;
}Queue;//队列的初始化
void QueueInit(Queue* pq);//队列的销毁
void QueueDestory(Queue* pq);//队尾入数据
void QueuePush(Queue* pq, QueueDataType x);//队头出数据
void QueuePop(Queue* pq);//获取队头数据
QueueDataType QueueFront(Queue* pq);//获取队尾数据
QueueDataType QueueBack(Queue* pq);//获取队列有效数据个数
int QueueSize(Queue* pq);//判断队列是否为空
bool QueueEmpty(Queue* pq);//队列的初始化
void QueueInit(Queue* pq)
{assert(pq);pq->head = NULL;pq->tail = NULL;pq->size = 0;
}//队列的销毁
void QueueDestory(Queue* pq)
{assert(pq);QNode* cur = pq->head;while (cur){QNode* Next = cur->next;free(cur);cur = Next;}pq->head = NULL;pq->tail = NULL;pq->size = 0;
}//队尾入数据
void QueuePush(Queue* pq, QueueDataType x)
{//开辟一个新节点QNode* node = (QNode*)malloc(sizeof(QNode));if (node == NULL){perror("malloc fail");return;}node->val = x;node->next = NULL;//队列中没有节点if (pq->tail == NULL){pq->head = node;pq->tail = node;}else{pq->tail->next = node;pq->tail = node;}pq->size++;
}//队头出数据
void QueuePop(Queue* pq)
{assert(pq);assert(pq->size != 0);QNode* next = pq->head->next;free(pq->head);pq->head = next;if (pq->head == NULL){pq->tail = NULL;}pq->size--;
}//获取队头数据
QueueDataType QueueFront(Queue* pq)
{assert(pq);return pq->head->val;
}//获取队尾数据
QueueDataType QueueBack(Queue* pq)
{assert(pq);return pq->tail->val;
}//获取队列有效数据个数
int QueueSize(Queue* pq)
{assert(pq);return pq->size;
}//判断队列是否为空
bool QueueEmpty(Queue* pq)
{assert(pq);return pq->size == 0;
}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* empty=&(obj->q1);Queue* noempty=&(obj->q2);if(!QueueEmpty(&(obj->q1))){empty=&(obj->q2);noempty=&(obj->q1);}//把前size-1个数据移到空队列中while(QueueSize(noempty)>1){QueuePush(empty,QueueFront(noempty));QueuePop(noempty);}QueueDataType top=QueueFront(noempty);QueuePop(noempty);return top;
}int myStackTop(MyStack* 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；
}

四.循环队列

. - 力扣（LeetCode）

1.定义：一种线性结构，基于先进先出原则，将队尾与队头连接起来构成循环

2.特点：有限空间，保证先进先出，从重复使用

3.思路：可以用数组实现，也可以用链表实现

用数组实现较为简单，用链表实现比较困难，下面小编将从两个角度来解释原因：

1>若使用单链表，在删除数据时不好获取待删除数据的前一个节点的位置，无法实现队尾的改变

2>若使用双向链表，占用内存太大，而且此时在判空判满时需要比较两个节点的地址比较麻烦

4.代码实现(以数组实现为例)：

(1)循环队列的结构体定义：数组指针，队头的下标，队尾下一个数据的下标，空间的大小

typedef struct {int* a;int head;//指向头int rear;//指向尾的下一个int k;//空间大小
} MyCircularQueue;

(2)循环队列的创建：

1>为循环队列malloc一块空间，防止出函数时，结构体被销毁

2>由于rear指向队尾的下一个数据，若直接开辟指定大小的空间，在插入最后一个数据时，rear会越界访问，此时我们称该情况为假溢出现象，为了解决假溢出我们可以采取以下两种措施

【1】为数组多开一块空间

【2】

MyCircularQueue* myCircularQueueCreate(int k) {MyCircularQueue* pc=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));//多开一块空间，解决假溢出问题pc->a=(int*)malloc(sizeof(int)*(k+1));pc->head=0;pc->rear=0;pc->k=k;return pc;
}

(3)循环队列的销毁：先销毁为数组开辟的空间，再销毁循环队列

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

(4)循环队列的判空：

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {assert(obj);//头与尾的下一个指向同一位置即为空return obj->head==obj->rear;
}

(5)循环队列的判满：

bool myCircularQueueIsFull(MyCircularQueue* obj) {assert(obj);//尾的下一个和头指向的位置相同即为满return obj->head==(obj->rear+1)%(obj->k+1);
}

(6)循环队列插入数据：在队尾插入数据，让rear向后走一步，为了避免rear++后越界访问，需要将自增后的rear模上k+1，使其在有效下标内且可以完成循环

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {assert(obj);if(myCircularQueueIsFull(obj)){return false;}obj->a[obj->rear]=value;obj->rear++;obj->rear%=(obj->k+1);return true;
}

(7)循环队列删除数据：删除队头数据，让head向后走一步，为了避免head++后越界访问，需要将自增后的head模上k+1，使其在有效下标内且可以完成循环(原理同上，就不再赘述了)

ool myCircularQueueDeQueue(MyCircularQueue* obj) {assert(obj);if(myCircularQueueIsEmpty(obj)){return false;}obj->head++;obj->head%=(obj->k+1);return true;
}

(8)获取队尾元素：


int myCircularQueueRear(MyCircularQueue* obj) {if(myCircularQueueIsEmpty(obj)){return -1;}else{return obj->rear==0?obj->a[obj->k]:obj->a[obj->rear-1];}
}

(9)获取队头元素：

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

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

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

相关文章

Redis数据结构-RedisObject

Redis数据结构-RedisObject

1.7 Redis数据结构-RedisObject Redis中的任意数据类型的键和值都会被封装为一个RedisObject，也叫做Redis对象，源码如下： 1、什么是redisObject： 从Redis的使用者的角度来看，⼀个Redis节点包含多个database&#xff…
阅读更多...
(实测验证)Gitee代码托管尝试（一）——克隆/下载

(实测验证)Gitee代码托管尝试（一）——克隆/下载

一、登录 Gitee（码云）代码托管平台： Gitee - 基于 Git 的代码托管和研发协作平台 新建个人账户如下： 二、SSH 公钥设置 1、在git安装目录打开“git-cmd.exe”; 2、通过命令 ssh-keygen 生成 SSH Key： ssh-keygen …
阅读更多...
层次式体系结构概述

层次式体系结构概述

1.软件体系结构 软件体系结构可定义为：软件体系结构为软件系统提供了结构、行为和属性的高级抽象，由构成系统的元素描述、这些元素的相互作用、指导元素集成的模式以及这些模式的约束组成。软件体系结构不仅指定了系统的组织结构和拓扑结构，并…
阅读更多...
[ciscn 2022 东北赛区]math

[ciscn 2022 东北赛区]math

1.题目 import gmpy2 from Crypto.Util.number import * from flag import flag assert flag.startswith(b"flag{") assert flag.endswith(b"}") messagebytes_to_long(flag) def keygen(nbit, dbit):if 2*dbit < nbit:while True:a1 getRandomNBitIn…
阅读更多...
公共命名空间和RHP

公共命名空间和RHP

概述 RHP的全称是&#xff1a;the little Robot that Helped me Program&#xff0c;帮我编程序的小机器人。 RHP必然存在&#xff0c;C语言的宏、C的模板&#xff0c;都是RHP&#xff1b;更复杂的例子&#xff0c;是lex和yacc&#xff0c;它们是制作程序的程序&#xff0c;也…
阅读更多...
浅析扩散模型与图像生成【应用篇】(二十五)——Plug-and-Play

浅析扩散模型与图像生成【应用篇】(二十五)——Plug-and-Play

25. Plug-and-Play: Diffusion Features for Text-Driven Image-to-Image Translation 该文提出一种文本驱动的图像转换方法&#xff0c;输入一张图像和一个目标文本描述&#xff0c;按照文本描述对输入图像进行转换&#xff0c;得到目标图像。图像转换任务其实本质上属于图像编…
阅读更多...
机器学习（3）

机器学习（3）

目录 3-1线性回归 3-2最小二乘解 3-3多元线性回归 3-4广义线性模型 3-5对率回归 3-6对率回归求解 3-7线性判别分析 3-8LDA的多类推广 3-9多分类学习基本思路 3-10类别不平衡 3-1线性回归 线性模型为什么重要&#xff1f; 人类在考虑问题时&#xff0c;通常…
阅读更多...
MybatisPlus拓展功能(内附全功能代码)

MybatisPlus拓展功能(内附全功能代码)

目录 代码生成 静态工具 案例 逻辑删除 枚举处理器 ​编辑 Json处理器 分页插件功能 ​编辑 案例 封装转换方法 代码生成 静态工具 案例 Overridepublic UserVO queryUserAndAddressById(long id) { // 1.查询用户User user getById(id);if (user null || …
阅读更多...
【电路笔记】-有源低通滤波器

【电路笔记】-有源低通滤波器

有源低通滤波器 文章目录 有源低通滤波器1、概述2、有源低通滤波器2.1 一阶低通滤波器2.2 带放大功能的有源低通滤波器3、有源低通滤波器示例4、二阶低通有源滤波器通过将基本的 RC 低通滤波器电路与运算放大器相结合，我们可以创建一个具有放大功能的有源低通滤波器电路。 1、…
阅读更多...
全网最全的Postman接口自动化测试！

全网最全的Postman接口自动化测试！

该篇文章针对已经掌握 Postman 基本用法的读者&#xff0c;即对接口相关概念有一定了解、已经会使用 Postman 进行模拟请求的操作。 当前环境&#xff1a; Window 7 - 64 Postman 版本&#xff08;免费版&#xff09;&#xff1a;Chrome App v5.5.3 不同版本页面 UI 和部分…
阅读更多...
一种基于电场连续性的高压MOSFET紧凑模型，用于精确表征电容特性

一种基于电场连续性的高压MOSFET紧凑模型，用于精确表征电容特性

来源&#xff1a;A Compact Model of High-Voltage MOSFET Based on Electric Field Continuity for Accurate Characterization of Capacitance&#xff08;TED 24年&#xff09; 摘要 本文提出了一种新的高压MOSFET&#xff08;HV MOS&#xff09;紧凑模型&#xff0c;以消…
阅读更多...
Spring-Cloud 微服务

Spring-Cloud 微服务

1. 微服务架构 1.1 单体应用架构---内部项目【OA WMS等】 将项目所有模块(功能)打成jar或者war&#xff0c;然后部署一个进程 优点: 1:部署简单:由于是完整的结构体&#xff0c;可以直接部署在一个服务器上即可。 2:技术单一:项目不需要复杂的技术栈&#xff0c;往往一套熟悉的…
阅读更多...
就这？轻轻松松在RK356X Android11适配ML307R Cat.1模组

就这？轻轻松松在RK356X Android11适配ML307R Cat.1模组

开源鸿蒙硬件方案领跑者 触觉智能 Industio 本文基于IDO-SXB3568主板&#xff0c;介绍Android11平台上适配中移物联ML307R Cat.1 4G模组的方法。该方法适用于触觉所有RK356X的主板。 IDO-SXB3568是触觉智能推出的RK3568行业主板&#xff0c;预计6月上旬正式上架售卖。该行业主…
阅读更多...
基于卷积神经网络CNN，使用二维卷积Conv2D实现MNIST数字识别的四种方法

基于卷积神经网络CNN，使用二维卷积Conv2D实现MNIST数字识别的四种方法

前言 系列专栏&#xff1a;机器学习&#xff1a;高级应用与实践【项目实战100】【2024】✨︎ 在本专栏中不仅包含一些适合初学者的最新机器学习项目&#xff0c;每个项目都处理一组不同的问题&#xff0c;包括监督和无监督学习、分类、回归和聚类&#xff0c;而且涉及创建深度学…
阅读更多...
文件系统，磁盘的物理存储结构和逻辑存储结构

文件系统，磁盘的物理存储结构和逻辑存储结构

问题导入 在计算机中不是所有的文件都是被打开的&#xff0c;只有我们要用的文件的被打开&#xff0c;大部分文件&#xff08;当前不需要访问的文件&#xff09;&#xff0c;都在磁盘中保存着。问题是没有被打开的文件是否需要管理&#xff1f; 这就好比我有十套衣服&#xff…
阅读更多...
Elasticsearch 搜索引擎实现对文档内容进行快速检索（保姆级教程）

Elasticsearch 搜索引擎实现对文档内容进行快速检索（保姆级教程）

本文主要讲解ES如何从提取文档中提取内容&#xff08;word、pdf、txt、excel等文件类型&#xff09;&#xff0c;实现快速检索文档内容实现。 特别说明一下&#xff0c;为什么用7.10.0版本&#xff0c;因为在项目中除了精确匹配的要求&#xff0c;也会有模糊查询&#xff08;关…
阅读更多...
如何选择开箱机厂家，看这几点！

如何选择开箱机厂家，看这几点！

在现代化生产线上&#xff0c;开箱机作为自动化包装设备的重要组成部分&#xff0c;其选择对于提升生产效率、降低成本至关重要。然而&#xff0c;市场上开箱机厂家众多&#xff0c;如何挑选出合适的合作伙伴成为了许多企业面临的难题。与星派一起探讨如何选择开箱机厂家&#…
阅读更多...
Python实现管线建模 || 1.圆直管、方管

Python实现管线建模 || 1.圆直管、方管

在Python 中可以使用开源的三维库&#xff08;例如 trimesh&#xff09;来创建简单的管线模型&#xff0c;并将其导出为多种 3D 模型格式。本文为大家介绍如何使用 trimesh 创建圆直管并导出为 .obj 等通用三维格式模型。 pip安装trimesh pip install trimesh 支持的文件格式…
阅读更多...
easyx快速入门1

easyx快速入门1

1.基本说明 EasyX 是针对 C 的图形库&#xff0c;可以帮助 C/C 初学者快速上手图形和游戏编程。 比如&#xff0c;可以基于 EasyX 图形库很快的用几何图形画一个房子&#xff0c;或者一辆移动的小车&#xff0c;可以编写俄罗斯方块、贪吃蛇、黑白棋等小游戏&#xff0c;可以练…
阅读更多...
战网国际服加速器用哪个好 暴雪战网好用加速器介绍

战网国际服加速器用哪个好 暴雪战网好用加速器介绍

战网国际版&#xff0c;又称Battle.net环球版&#xff0c;是暴雪娱乐操盘的全球性游戏互动平台&#xff0c;它跨越地理界限&#xff0c;服务于全球游戏爱好者。与地区限定版本相异&#xff0c;国际版赋予玩家自由进入暴雪旗下众多经典游戏的权利&#xff0c;无论身处何方&#…
阅读更多...
最新文章

Copyright @ 2022~2023