【数据结构】队列的完整实现

news2025/5/24 19:08:22

队列的完整实现

  • 队列的完整实现
  • github地址
  • 前言
  • 1. 队列的概念及其结构
    • 1.1 概念
    • 1.2 组织结构
  • 2. 队列的实现
    • 接口一览
    • 结构定义与架构
    • 初始化和销毁
    • 入队和出队
    • 取队头队尾数据
    • 获取size和判空
  • 完整代码与功能测试
  • 结语

队列的完整实现

github地址

有梦想的电信狗

前言

​ 队列（Queue）作为一种基础且重要的数据结构，在计算机科学中扮演着关键角色。无论是操作系统的任务调度、网络数据包的管理，还是算法中的广度优先搜索（BFS），队列的“先进先出”（FIFO）特性都使其成为不可或缺的工具。理解队列的实现原理，不仅能帮助开发者更高效地处理数据，还能为后续学习复杂的数据结构打下坚实基础。

​ 本文将以 链式结构 为核心，详细介绍队列的完整实现。从结构设计、接口定义到功能测试，一步步剖析如何用C语言实现一个高效、健壮的队列。文章重点讲解入队（push）、出队（pop）、获取队头/队尾元素等核心操作，并通过清晰的代码示例和测试案例，帮助读者深入理解队列的内部机制。此外，所有代码已在GitHub开源，方便读者参考和扩展。

1. 队列的概念及其结构

1.1 概念

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

  • 入队列：进行插入操作的一端称为队尾，入队常被称为push
  • 出队列：进行删除操作的一端称为队头，出队常被称为pop
  • 如下图所示
    在这里插入图片描述

1.2 组织结构

  • 队列可以使用数组和链表的结构实现，使用链表的结构实现更优一些。

  • 因为如果使用数组的结构，出队列时，在数组头上出数据，效率会比较低

  • 而对于链表实现的队列来说，入队对应尾插操作，出队对应头删操作。在链表中，头删和尾插操作只需要O(1)时间复杂度，因此队列更适合使用链表来实现，本文我们采用单链表来实现。

在这里插入图片描述

2. 队列的实现

接口一览

//初始化 与 销毁队列
void QueueInit(Queue* pQueue);
void QueueDestroy(Queue* pQueue);

// 队尾入队列    队头出队列
void QueuePush(Queue* pQueue, QDataType data);
void QueuePop(Queue* pQueue);

// 获取队列头部元素   /获取队列尾部元素
QDataType QueueFront(Queue* pQueue);
QDataType QueueBack(Queue* pQueue);

//获取队列中有效元素个数	检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueSize(Queue* pQueue);
bool QueueEmpty(Queue* pQueue);

结构定义与架构

结构：

//队列，先进先出，数组的话在头部出数据不方便，因此用链表来实现，单链表
typedef int QDataType;

typedef struct QNode {		//链式队列，用单链表实现
	struct QNode* next;
	QDataType data;
}QNode;

//队列中 用两个指针来指示 队头和队尾，方便入队和出队
typedef struct Queue {
	QNode* head;
	QNode* tail;
	int size;
}Queue;
  • 使用typedef int QDataType方便队列中存放不同的数据类型
  • QNode表示我们链表中一个个的结点，内部包含next指针和数据data
  • 使用struct Queue结构来表示整个队列，其中：
    • 规定两个QNode*的指针，分别保存链表第一个结点和尾结点的地址(分别指向第一个结点和最后一个结点)
    • 定义int size来保存队列中的有效元素个数。

架构图如下：
在这里插入图片描述

初始化和销毁

初始化：

//初始化 与 销毁队列
void QueueInit(Queue* pQueue) {
	assert(pQueue);
	pQueue->head = pQueue->tail = NULL;
	pQueue->size = 0;
}
  • 通过Queue结构体的指针pQueue，来访问结构体中的成员head和tail，通过head和tail指针和链表的特性，可以访问到链表中的每个结点。head和tail指针主要是为了方便访问队头结点和队尾结点。
  • assert(pQueue)保证Queue结构存在
  • 初始化队列：
    • 链表中无节点时，head和tail指针都置为NULL
    • 初始化size为0

销毁：

//销毁
void QueueDestroy(Queue* pQueue) {
	assert(pQueue);
    // 空链表也可以销毁，因此无需断言链表非空
	QNode* cur = pQueue->head;
	while (cur != NULL) {
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pQueue->head = pQueue->tail = NULL;
	pQueue->size = 0;
}
  • assert(pQueue)保证Queue结构存在
  • QNode* cur = pQueue->head：cur保存当前头结点的地址
    • while循环依次释放每一个结点
    • 保存cur的下一个节点cur->next
    • free(cur)释放当前结点，cur移动指向下一个节点，直到NULL时结束
  • pQueue->head = pQueue->tail = NULL：将head和tail指针各自置NULL
  • pQueue->size = 0最后将size置0

入队和出队

入队：

// 队尾入队列    队头出队列
void QueuePush(Queue* pQueue, QDataType data) {
	assert(pQueue);
    // 开辟新结点，并将数据置于新结点中
	QNode* newNode = (QNode*)malloc(sizeof(QNode));
	if (newNode == NULL) {
		perror("malloc failed\n");
		return;
	}
	newNode->data = data;
	newNode->next = NULL;
	// 初始化后，head 和 tail 都为NULL
	if (pQueue->head == NULL) {
		assert(pQueue->tail == NULL);	// head为NULL时，tail必须也为NULL
		pQueue->head = pQueue->tail = newNode;
	}
	else {
		pQueue->tail->next = newNode;
		pQueue->tail = newNode;
	}
	pQueue->size++;
}
  • assert(pQueue)保证Queue结构存在
  • QNode* newNode = (QNode*)malloc(sizeof(QNode)); if (newNode == NULL) { perror("malloc failed\n"); return; }开辟一个新结点，并进行初始化。
  • 初始化QNode后，push 一个结点本质是单链表的尾插，有两种情况：
    • 队列为空(队列中无节点)时：新开辟的QNode应当成为链表中的第一个节点，pQueue->head = pQueue->tail = newNode操作调整首尾指针即可。
    • 队列中已有其他结点时：此时是单链表的尾插。
      • pQueue->tail->next = newNode：新结点链入原链表
      • pQueue->tail = newNode：更改尾指针指向
  • push过后，pQueue->size++，队列的size应当++

出队：

v1版本仅实现：

void QueuePop(Queue* pQueue) {
	assert(pQueue);
	assert(pQueue->head != NULL);

	//if(pQueue->head->next == NULL){}	//考虑只剩一个结点的情况
    if (pQueue->head == pQueue->tail) {	
        free(pQueue->head);
        pQueue->head = pQueue->tail = NULL;
    }
    else {
        QNode* cur = pQueue->head;
        pQueue->head = pQueue->head->next;
        free(cur);
        cur = NULL;
    }
    pQueue->size--;
}
  • assert(pQueue)：断言队列存在，assert(pQueue->head != NULL)，确保pop时队列内有元素
  • pop出队时，销毁第一个结点，确保队列存在且有元素后，此处存在两种情况
    • 当前仅剩一个结点时：pQueue->head == pQueue->tail，直接free当前头结点，将head和tail指针置NULL即可
    • 当前存在多个节点时(else)：
      • QNode* cur = pQueue->head：记录下当前的头结点
      • pQueue->head = pQueue->head->next：头指针向后移动
      • free(cur)后cur = NULL释放之前的头结点的空间，并将cur置NULL
  • pop后size应当--

v2版本优化：

  • 可以看到，上述的代码中存在多次free，且都是对要被删除的结点进行free，那么是否可以优化为一次free呢
void QueuePop(Queue* pQueue) {
	assert(pQueue);
	assert(pQueue->head != NULL);
	//优化版本
	QNode* cur = pQueue->head;
	if (pQueue->head == pQueue->tail)
		pQueue->head = pQueue->tail = NULL;
	else
		pQueue->head = pQueue->head->next;

	free(cur);
    cur = NULL;
	pQueue->size--;
}
  • assert(pQueue)：断言队列存在，assert(pQueue->head != NULL)，确保pop时队列内有元素
  • QNode* cur = pQueue->head：不管队列中剩余几个结点，最终都要free头结点，那么cur直接保存头结点的地址，方便进行操作
  • pQueue->head == pQueue->tail仅剩一个结点时：仅需对head和tail指针做修改。有多个节点时，pQueue->head = pQueue->head->next，head指针向后移动。
  • 最终cur内保存了要被删除的结点的地址，直接free(cur)并置NULL
  • pop后size应当--

取队头队尾数据

获取队头数据：

// 获取队列头部元素   获取队列尾部元素
QDataType QueueFront(Queue* pQueue) {
	assert(pQueue);
	//确保队列非空
	assert(!QueueEmpty(pQueue));
	return pQueue->head->data;
}
  • assert(pQueue)确保队列存在，assert(!QueueEmpty(pQueue))确保队列非空，非空队列内才有数据
  • 头部数据：return pQueue->head->data，通过头指针head访问队列内第一个结点的数据

获取队尾数据：

//获取队列尾部元素
QDataType QueueBack(Queue* pQueue) {
	assert(pQueue);
	//确保队列非空
	assert(!QueueEmpty(pQueue));
	return pQueue->tail->data;
}
  • assert(pQueue)确保队列存在，assert(!QueueEmpty(pQueue))确保队列非空，非空队列内才有数据
  • 尾部数据：return pQueue->tail->data，通过尾指针tail访问队列内最后一个结点的数据

获取size和判空

获取size：

int QueueSize(Queue* pQueue) {
	assert(pQueue);
	return pQueue->size;
}
  • assert(pQueue)：断言指针非空，确保Queue结构体存在
  • 直接返回size即可得到元素个数
    • 这里就体现出我们在Queue结构中添加一个size成员的好处，只需在每次Push/Pop后对size进行加减，即可方便的得到队列的size
    • 如果Queue结构内不维护一个size变量的话，由于我们的队列是基于单链表实现的，每次获取队列的大小时都只能遍历链表来得到size，遍历的时间复杂度较高。

判空：

bool QueueEmpty(Queue* pQueue) {
	assert(pQueue);
	//return (pQueue->head == NULL && pQueue->tail == NULL);
	return pQueue->size == 0;	// size为0时为空
}
  • assert(pQueue)：断言指针非空，确保Queue结构体存在
  • pQueue->size == 0或pQueue->head == NULL && pQueue->tail == NULL，两个条件均可以标识队列为空

完整代码与功能测试

完整代码如下：

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

//队列，先进先出，数组的话在头部出数据不方便，因此用链表来实现，单链表
typedef int QDataType;

typedef struct QNode {		//链式队列，用单链表实现
	struct QNode* next;
	QDataType data;
}QNode;

//队列中 用两个指针来指示 队头和队尾，方便入队和出队
typedef struct Queue {
	QNode* head;
	QNode* tail;
	int size;
}Queue;

//初始化 与 销毁队列
void QueueInit(Queue* pQueue);
void QueueDestroy(Queue* pQueue);

// 队尾入队列    队头出队列
void QueuePush(Queue* pQueue, QDataType data);
void QueuePop(Queue* pQueue);

// 获取队列头部元素   /获取队列尾部元素
QDataType QueueFront(Queue* pQueue);
QDataType QueueBack(Queue* pQueue);

//获取队列中有效元素个数	检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueSize(Queue* pQueue);
bool QueueEmpty(Queue* pQueue);

// #include "Queue.h" 多文件编译时，需正确包含头文件

//初始化 与 销毁队列
void QueueInit(Queue* pQueue) {
	assert(pQueue);
	pQueue->head = pQueue->tail = NULL;
	pQueue->size = 0;
}
//销毁
void QueueDestroy(Queue* pQueue) {
	assert(pQueue);
	QNode* cur = pQueue->head;
	while (cur != NULL) {
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pQueue->head = pQueue->tail = NULL;
	pQueue->size = 0;
}

// 队尾入队列    队头出队列
void QueuePush(Queue* pQueue, QDataType data) {
	assert(pQueue);
	QNode* newNode = (QNode*)malloc(sizeof(QNode));
	if (newNode == NULL) {
		perror("malloc failed\n");
		return;
	}
	newNode->data = data;
	newNode->next = NULL;
	// 初始化后，head 和 tail 都为NULL
	if (pQueue->head == NULL) {
		assert(pQueue->tail == NULL);	// head为NULL时，tail必须也为NULL
		pQueue->head = pQueue->tail = newNode;
	}
	else {
		pQueue->tail->next = newNode;
		pQueue->tail = newNode;
	}
	pQueue->size++;
}
//队列的头删法
void QueuePop(Queue* pQueue) {
	assert(pQueue);
	assert(pQueue->head != NULL);

	if(pQueue->head->next == NULL){}	//考虑只剩一个结点的情况
	//if (pQueue->head == pQueue->tail) {	
	//	free(pQueue->head);
	//	pQueue->head = pQueue->tail = NULL;
	//}
	//else {
	//	QNode* cur = pQueue->head;
	//	pQueue->head = pQueue->head->next;
	//	free(cur);
	//	cur = NULL;
	//}
	//pQueue->size--;

	//优化版本
	QNode* cur = pQueue->head;
	if (pQueue->head == pQueue->tail)
		pQueue->head = pQueue->tail = NULL;
	else
		pQueue->head = pQueue->head->next;

	free(cur);
	cur = NULL;
	pQueue->size--;
}

// 获取队列头部元素   获取队列尾部元素
QDataType QueueFront(Queue* pQueue) {
	assert(pQueue);
	//确保队列非空
	assert(!QueueEmpty(pQueue));
	return pQueue->head->data;
}
//获取队列尾部元素
QDataType QueueBack(Queue* pQueue) {
	assert(pQueue);
	//确保队列非空
	assert(!QueueEmpty(pQueue));
	return pQueue->tail->data;
}

//获取队列中有效元素个数	检测队列是否为空，如果为空返回非零结果，如果非空返回0
// 双向链表中，不能用 哨兵位的数据  来存储 链表的长度
// 之前的实现中，结点内存放的数据是int，导致哨兵位内的数据位类型也是int,
int QueueSize(Queue* pQueue) {
	assert(pQueue);
	return pQueue->size;
}
bool QueueEmpty(Queue* pQueue) {
	assert(pQueue);
	//return (pQueue->head == NULL && pQueue->tail == NULL);
	return pQueue->size == 0;	// size为0时为空
}

功能测试：

// 需正确包含头文件
#include "Queue.h"

void TestQueue() {
	Queue queue;
	QueueInit(&queue);
	QueuePush(&queue, 1);
	QueuePush(&queue, 2);
	QueuePush(&queue, 3);
	QueuePush(&queue, 4);
	QueuePush(&queue, 6);

	// 遍历的代码
	/*while (!QueueEmpty(&queue)) {
		printf("%d ", QueueFront(&queue));
		QueuePop(&queue);
	}*/
	
	printf("队尾：%d  有效元素个数：%d\n", QueueBack(&queue), QueueSize(&queue));
	printf("队头：%d  有效元素个数：%d\n", QueueFront(&queue), QueueSize(&queue));

	QueuePop(&queue);
	printf("队尾：%d  有效元素个数：%d\n", QueueBack(&queue), QueueSize(&queue));
	printf("队头：%d  有效元素个数：%d\n", QueueFront(&queue), QueueSize(&queue));

	QueuePop(&queue);
	printf("队尾：%d  有效元素个数：%d\n", QueueBack(&queue), QueueSize(&queue));
	printf("队头：%d  有效元素个数：%d\n", QueueFront(&queue), QueueSize(&queue));

	QueuePop(&queue);
	QueuePop(&queue);
	printf("队列有效元素个数：%d\n", QueueSize(&queue));
	while (!QueueEmpty(&queue)) {
		printf("%d ", QueueFront(&queue));
		QueuePop(&queue);
	}

	QueueDestroy(&queue);
}

//函数调用的栈帧  和  数据结构的栈
// 函数调用的栈帧  是操作系统层面对内存区域的划分
// 和  数据结构的栈

int main() {

	TestQueue();
	return 0;
}

在这里插入图片描述

结语

通过本文的学习，我们完成了队列的完整实现：从结构体设计到核心接口的实现，再到功能验证。关键点包括：

  1. 链式结构的优势：使用单链表实现队列，确保入队（尾插）和出队（头删）操作的时间复杂度均为 O(1)。
  2. 双指针的妙用：通过 head 和 tail 指针分别标记队头和队尾，避免了遍历链表的性能损耗。
  3. 健壮性保障：通过断言（assert）确保操作合法性，并结合 size 字段快速判断队列状态。

希望本文能帮助你彻底掌握队列的实现原理，并激发对数据结构更深层次的探索。

以上就是本文的所有内容了，如果觉得文章对你有帮助，欢迎 点赞⭐收藏 支持！如有疑问或建议，请在评论区留言交流，我们一起进步

分享到此结束啦
一键三连，好运连连！

你的每一次互动，都是对作者最大的鼓励！

征程尚未结束，让我们在广阔的世界里继续前行！ 🚀

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

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

相关文章

根据YOLO数据集标签计算检测框内目标面积占比（YOLO7-10都适用）

根据YOLO数据集标签计算检测框内目标面积占比（YOLO7-10都适用）

程序&#xff1a; 路径改成自己的&#xff0c;阈值可以修改也可以默认 #zhouzhichao #25年5月17日 #计算时频图中信号面积占检测框面积的比值import os import numpy as np import pandas as pd from PIL import Image# Define the path to the directory containing the lab…
阅读更多...
LLM笔记（九）KV缓存（2）

LLM笔记（九）KV缓存（2）

文章目录 1. 背景与动机2. 不使用 KV Cache 的情形2.1 矩阵形式展开2.2 计算复杂度 3. 使用 KV Cache 的优化3.1 核心思想3.2 矩阵形式展开3.3 计算复杂度对比 4. 总结5. GPT-2 中 KV 缓存的实现分析5.1 缓存的数据结构与类型5.2 在注意力机制 (GPT2Attention) 中使用缓存5.3 缓…
阅读更多...
LVS 负载均衡集群应用实战

LVS 负载均衡集群应用实战

前提：三台虚拟机，有nginx，要做负载 1. LVS-server 安装lvs管理软件 [root@lvs-server ~]# yum -y install ipvsadm 程序包：ipvsadm（LVS管理工具） 主程序：/usr/sbin/ipvsadm 规则保存工具：/usr/sbin/ipvsadm-save > /path/to/file 配置文件：/etc/sysconfig/ipvsad…
阅读更多...
MySQL——基本查询内置函数

MySQL——基本查询内置函数

目录 CRUD Create Retrieve where order by limit Update Delete 去重操作 聚合函数 聚合统计 内置函数 日期函数 字符函数 数学函数 其它函数 实战OJ 批量插入数据 找出所有员工当前薪水salary情况 查找最晚入职员工的所有信息 查找入职员工时间升序排…
阅读更多...
Day34打卡 @浙大疏锦行

Day34打卡 @浙大疏锦行

知识点回归&#xff1a; CPU性能的查看&#xff1a;看架构代际、核心数、线程数GPU性能的查看&#xff1a;看显存、看级别、看架构代际GPU训练的方法&#xff1a;数据和模型移动到GPU device上类的call方法&#xff1a;为什么定义前向传播时可以直接写作self.fc1(x) 作业 计算资…
阅读更多...
AdGuard解锁高级版(Nightly)_v4.10.36 安卓去除手机APP广告

AdGuard解锁高级版(Nightly)_v4.10.36 安卓去除手机APP广告

AdGuard解锁高级版(Nightly)_v4.10.36 安卓去除手机APP广告 AdGuard Nightly是AdGuard团队为及时更新软件而推出的最新测试版本&#xff0c;适合追求最新功能和愿意尝试新版本的用户。但使用时需注意其潜在的不稳定性和风险。…
阅读更多...
C++修炼：红黑树的模拟实现

C++修炼：红黑树的模拟实现

Hello大家好&#xff01;很高兴我们又见面啦&#xff01;给生活添点passion&#xff0c;开始今天的编程之路&#xff01; 我的博客&#xff1a;<但凡. 我的专栏&#xff1a;《编程之路》、《数据结构与算法之美》、《题海拾贝》、《C修炼之路》 欢迎点赞&#xff0c;关注&am…
阅读更多...
基于Python+YOLO模型的手势识别系统

基于Python+YOLO模型的手势识别系统

本项目是一个基于Python、YOLO模型、PyQt5的实时手势识别系统&#xff0c;通过摄像头或导入图片、视频&#xff0c;能够实时识别并分类不同的手势动作。系统采用训练好的深度学习模型进行手势检测和识别&#xff0c;可应用于人机交互、智能控制等多种场景。 1、系统主要功能包…
阅读更多...
自制操作系统day10叠加处理

自制操作系统day10叠加处理

day10叠加处理 叠加处理&#xff08;harib07b&#xff09; 现在是鼠标的叠加处理&#xff0c;以后还有窗口的叠加处理 涉及图层 最上面小图层是鼠标指针&#xff0c;最下面的一张图层用来存放桌面壁纸。移动图层的方法实现鼠标指针的移动以及窗口的移动。 struct SHEET { u…
阅读更多...
鸿蒙Flutter实战：23-混合开发详解-3-源码模式引入

鸿蒙Flutter实战：23-混合开发详解-3-源码模式引入

引言 在前面的文章混合开发详解-2-Har包模式引入中&#xff0c;我们介绍了如何将 Flutter 模块打包成 Har 包&#xff0c;并引入到原生鸿蒙工程中。本文中&#xff0c;我们将介绍如何通过源码依赖的方式&#xff0c;将 Flutter 模块引入到原生鸿蒙工程中。 创建工作 创建一个…
阅读更多...
leetcode:2469. 温度转换（python3解法，数学相关算法题）

leetcode:2469. 温度转换（python3解法，数学相关算法题）

难度&#xff1a;简单 给你一个四舍五入到两位小数的非负浮点数 celsius 来表示温度&#xff0c;以 摄氏度&#xff08;Celsius&#xff09;为单位。 你需要将摄氏度转换为 开氏度&#xff08;Kelvin&#xff09;和 华氏度&#xff08;Fahrenheit&#xff09;&#xff0c;并以数…
阅读更多...
【软件安装】Windows操作系统中安装mongodb数据库和mongo-shell工具

【软件安装】Windows操作系统中安装mongodb数据库和mongo-shell工具

这篇文章&#xff0c;主要介绍Windows操作系统中如何安装mongodb数据库和mongo-shell工具。 目录 一、安装mongodb数据库 1.1、下载mongodb安装包 1.2、添加配置文件 1.3、编写启动脚本&#xff08;可选&#xff09; 1.4、启动服务 二、安装mongo-shell工具 2.1、下载mo…
阅读更多...
记共享元素动画导致的内存泄露

记共享元素动画导致的内存泄露

最近在给项目的预览图片页增加共享元素动画的时候&#xff0c;发现了LeakCanary一直报内存泄露。 LeakCanary日志信息 ┬─── │ GC Root: Thread object │ ├─ java.lang.Thread instance │ Leaking: NO (the main thread always runs) │ Thread name: main │ …
阅读更多...
Flyweight（享元）设计模式 软考 享元 和 代理属于结构型设计模式

Flyweight（享元）设计模式 软考 享元 和 代理属于结构型设计模式

1.目的&#xff1a;运用共享技术有效地支持大量细粒度的对象 Flyweight&#xff08;享元&#xff09;设计模式 是一种结构型设计模式&#xff0c;它的核心目的是通过共享对象来减少内存消耗&#xff0c;特别是在需要大量相似对象的场景中。Flyweight 模式通过将对象的共享细节与…
阅读更多...
服务器网络配置 netplan一个网口配置两个ip（双ip、辅助ip、别名IP别名）

服务器网络配置 netplan一个网口配置两个ip（双ip、辅助ip、别名IP别名）

文章目录 问答 问 # This is the network config written by subiquity network:ethernets:enp125s0f0:dhcp4: noaddresses: [192.168.90.180/24]gateway4: 192.168.90.1nameservers:addresses:- 172.0.0.207- 172.0.0.208enp125s0f1:dhcp4: trueenp125s0f2:dhcp4: trueenp125…
阅读更多...
响应面法（Response Surface Methodology ，RSM）

响应面法（Response Surface Methodology ，RSM）

响应面法是一种结合统计学和数学建模的实验优化技术&#xff0c;通过有限的实验数据&#xff0c;建立输入变量与输出响应之间的数学模型&#xff0c;找到最优操作条件。 1.RSM定义 RSM通过设计实验、拟合数学模型&#xff08;如多项式方程&#xff09;和分析响应曲面&#xff…
阅读更多...
Spring Boot 拦截器：解锁5大实用场景

Spring Boot 拦截器：解锁5大实用场景

一、Spring Boot中拦截器是什么 在Spring Boot中&#xff0c;拦截器&#xff08;Interceptor&#xff09;是一种基于AOP&#xff08;面向切面编程&#xff09;思想的组件&#xff0c;用于在请求处理前后插入自定义逻辑&#xff0c;实现权限校验、日志记录、性能监控等非业务功能…
阅读更多...
有两个Python脚本都在虚拟环境下运行，怎么打包成一个系统服务，按照顺序启动？

有两个Python脚本都在虚拟环境下运行，怎么打包成一个系统服务，按照顺序启动？

环境&#xff1a; SEMCP searx.webapp python 问题描述&#xff1a; 有两个python脚本都在虚拟环境下运行&#xff0c;怎么打包成一个系统服务&#xff0c;按照顺序启动&#xff1f; 解决方案&#xff1a; 将这两个 Python 脚本打包成有启动顺序的系统服务&#xff0c;最…
阅读更多...
Python 脚本执行命令的深度探索：方法、示例与最佳实践

Python 脚本执行命令的深度探索：方法、示例与最佳实践

在现代软件开发过程中&#xff0c;Python 脚本常常需要与其他工具和命令进行交互&#xff0c;以实现自动化任务、跨工具数据处理等功能。Python 提供了多种方式来执行外部命令&#xff0c;并获取其输出&#xff0c;重定向到文件&#xff0c;而不是直接在终端中显示。这种能力使…
阅读更多...
PotPlayer 4K 本地万能影音播放器

PotPlayer 4K 本地万能影音播放器

今日分享一款来自吾爱论坛大佬分享的啥都能播的的本地播放器&#xff0c;不管是不管是普通视频、4K超清、蓝光3D&#xff0c;还是冷门格式&#xff0c;它基本都能搞定。而且运行流畅不卡顿&#xff0c;电脑配置低也能靠硬件加速&#xff0c;让你根本停不下来。 自带解码器&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023