【C/C++】C语言实现顺序表

C语言实现顺序表

  • 简单描述
  • 代码
  • 运行结果

简单描述

  • 用codeblocks编译通过
  • 源码参考连接

https://gitee.com/IUuaena/data-structures-c.git

代码

  • common.h
#ifndef COMMON_H_INCLUDED
#define COMMON_H_INCLUDED#define LIST_INIT_CAPACITY  100 //!< 线性表初始化长度
#define LIST_INCREMENT      10  //!< 线性表增量
#define ELEM_TYPE           int //!< 线性表元素类型/*! @brief 函数返回值枚举 */
typedef enum {OK = 0,             //!< 正确NON_ALLOCATED = 1,  //!< 内存分配失败NON_EXISTENT = 2,   //!< 不存在OVERFLOW = 3,       //!< 溢出ERROR = 4           //!< 其他类型错误
} status_t;#endif // COMMON_H_INCLUDED
  • seq_list.h
#ifndef SEQ_LIST_H_INCLUDED
#define SEQ_LIST_H_INCLUDED#include "common.h"/*!* @brief **线性表*** @note*/
typedef struct {ELEM_TYPE* elements;    //!< 元素数组int length;             //!< 长度int capacity;           //!< 容量
} seq_list_t;// 顺序表初始化
status_t SeqListInit(seq_list_t* seq_list);// 顺序表插入
status_t SeqListInsert(seq_list_t* seq_list, int pos, ELEM_TYPE elem);// 顺序表删除元素
status_t SeqListDelete(seq_list_t* seq_list, int pos, ELEM_TYPE* elem);// 顺序表查找
int SeqListLocate(seq_list_t* seq_list, ELEM_TYPE elem, int (*compare)(ELEM_TYPE, ELEM_TYPE));// 顺序表的合并
status_t SeqListMerge(seq_list_t* list_a, seq_list_t* list_b, seq_list_t* merged_list);// 顺序表打印
void SeqListPrint(seq_list_t* seq_list);#endif // SEQ_LIST_H_INCLUDED

seq_list.c

/*!* @file seq_list.c* @author CyberDash计算机考研, cyberdash@163.com(抖音id:cyberdash_yuan)* @brief 顺序表源文件* @version 1.0.0* @date 2022-07-10* @copyright Copyright (c) 2021*  CyberDash计算机考研*/#include <stdlib.h>
#include <stdio.h>
#include "seq_list.h"/*!* @brief **顺序表初始化*** @param seq_list **顺序表**(指针)* @return **是否成功*** @note* 顺序表初始化* ----------* ----------* - 分配elements数组内存 \n* &emsp; **if** 内存分配失败 : \n* &emsp;&emsp; 返回NON_ALLOCATED \n*/
status_t SeqListInit(seq_list_t* seq_list)
{// 分配elements数组内存seq_list->elements = (ELEM_TYPE*)malloc(LIST_INIT_CAPACITY * sizeof(ELEM_TYPE));if (!seq_list->elements){return NON_ALLOCATED;}// 设置length和capacityseq_list->length = 0;                       // 空表长度为0seq_list->capacity = LIST_INIT_CAPACITY;    // 初始存储容量return OK;
}/*!* @brief **顺序表插入*** @param seq_list **顺序表**(指针)* @param pos **插入位置(插入到该位置结点的前一位置)*** @param elem **待插入元素*** @return **执行结果*** @note* 顺序表插入* ------------* ------------* **注**: 本顺序表实现, 索引从1开始, 区别于数组的从0开始\n* - 插入位置合法性判断 \n* &emsp; **if** 插入位置 < 1 或者 插入位置 > 长度 + 1 : \n* &emsp;&emsp; 返回OVERFLOW \n* - 满容量处理 \n* &emsp; **if** 线性表的容量已满(不扩容无法插入) : \n* &emsp;&emsp; 使用增量LIST_INCREMENT计算新的容量, 并分配新的elements数组内存 \n* &emsp;&emsp; **if** 内存分配失败 : \n* &emsp;&emsp;&emsp; 返回NON_ALLOCATED \n* &emsp;&emsp; 顺序表elements指针指向新数组 \n* &emsp;&emsp; 顺序表capacity增加容量数值 \n* - 插入位置(包含)后面的所有结点向后移动一位 \n* - 插入元素 \n* &emsp; 插入位置赋值 \n* &emsp; 表长+1 \n*/
status_t SeqListInsert(seq_list_t* seq_list, int pos, ELEM_TYPE elem)
{// 插入位置合法性判断if (pos < 1 || pos > seq_list->length + 1){return OVERFLOW;}// 满容量处理if (seq_list->length >= seq_list->capacity){// 使用增量LIST_INCREMENT计算新的容量, 并分配新的elements数组内存unsigned int new_capacity = (seq_list->capacity + LIST_INCREMENT) * sizeof(ELEM_TYPE);ELEM_TYPE* new_elements = (ELEM_TYPE*)realloc(seq_list->elements, new_capacity);if (!new_elements){return NON_ALLOCATED;}seq_list->elements = new_elements;      // 顺序表elements指针指向新数组seq_list->capacity += LIST_INCREMENT;   // 顺序表capacity增加容量数值}// 插入位置(包含)后面的所有结点向后移动一位ELEM_TYPE* insert_pos_elem = seq_list->elements + pos - 1;for (ELEM_TYPE* cur = seq_list->elements + seq_list->length - 1; cur >= insert_pos_elem; cur--){*(cur + 1) = *cur;}*insert_pos_elem = elem;  // 插入elemseq_list->length++;       // 表长增1return OK;
}/*!* @brief **顺序表删除元素*** @param seq_list **顺序表**(指针)* @param pos **被删除结点所在位置*** @param elem **被删除结点的保存变量*** @return **执行结果*** @note* 顺序表删除元素* ------------* ------------* - 删除节点位置正确性检查 \n* &emsp;**if** pos < 1 或者 pos > 线性表长度 : \n* &emsp;&emsp; 返回OVERFLOW \n* - 被删除结点的值赋给保存变量 \n* - 被删除结点后面的所有结点向前移动补位 \n* &emsp; **for loop** 被删除节点后侧所有所有结点 : \n* &emsp;&emsp; 当前结点值赋给前一节点 \n* - 表长减1 \n*/
status_t SeqListDelete(seq_list_t* seq_list, int pos, ELEM_TYPE* elem)
{if (pos < 1 || pos > seq_list->length){return OVERFLOW;}// 待删除节点值赋给保存变量ELEM_TYPE* delete_pos_elem = &(seq_list->elements[pos - 1]);*elem = *delete_pos_elem;ELEM_TYPE* last_elem = seq_list->elements + seq_list->length - 1;   // 表尾元素指针for (ELEM_TYPE* cur = delete_pos_elem + 1; cur <= last_elem; cur++){// 当前结点值赋给前一结点*(cur - 1) = *cur;}// 表长减1seq_list->length--;return OK;
}/*!* @brief **顺序表查找*** @param seq_list **顺序表**(指针)* @param elem **元素值*** @param compare **比较函数*** @return **元素位置*** @note* 顺序表查找* ------------* ------------* 如果没有该元素, 则返回0, 否则返回所在位置(首元素从1开始) \n* - 初始化pos和遍历指针cur \n* &emsp; pos初始化为1(首结点位置) \n* &emsp; cur指向elements数组首元素 \n* - 遍历线性表查找* &emsp; **while** 未遍历完线性表and未找到对应结点 : \n* &emsp;&emsp; pos加1 \n* &emsp;&emsp; cur指向后一元素 \n* - 返回位置 \n* &emsp; 如果找到位置, 返回位置 \n* &emsp; 如果没有找到位置, 返回0 \n*/
int SeqListLocate(seq_list_t* seq_list, ELEM_TYPE elem, int (*compare)(ELEM_TYPE, ELEM_TYPE))
{// 初始化pos和遍历指针curint pos = 1;                            // pos为第1个元素的位置ELEM_TYPE* cur = seq_list->elements;    // cur指向第1个元素的存储位置// 遍历线性表查找while (pos <= seq_list->length && (*compare)(*cur, elem) != 0){pos++;cur++;}// 返回位置if (pos <= seq_list->length){return pos;}return 0;
}/*!* @brief **顺序表的合并*** @param list_a **顺序表a*** @param list_b **顺序表b*** @param merged_list **合并后的顺序表*** @return **执行结果*** @note** 顺序表的合并* ----------* ----------* - 初始化两个顺序表的表头指针/表尾指针 \n* &emsp; list_a_cur指向表a的表头, list_b_cur指向表b的表头 \n* &emsp; list_a_last指向表a的表尾, list_b_last指向表b的表尾 \n* - 合并后的表设置属性分配内存 \n* &emsp; 设置长度/容量 \n* &emsp; 分配内存 \n* &emsp; **if** 内存分配失败 : \n* &emsp;&emsp; 返回NON_ALLOCATED \n* - 执行合并 \n* &emsp; **while** 任意一个表未合并完 : \n* &emsp;&emsp; **if** 表a当前元素 <= 表b当前元素 : \n* &emsp;&emsp;&emsp; 表a当前元素(*list_a_cur)插入合并表表尾 \n* &emsp;&emsp;&emsp; list_a_cur指向后面1位 \n* &emsp;&emsp; **else** (表a当前元素 > 表b当前元素) : \n* &emsp;&emsp;&emsp; 表b当前元素(*list_b_cur)插入合并表表尾 \n* &emsp;&emsp;&emsp; list_b_cur指向后面1位 \n* &emsp;&emsp; merged_list_cur指向后面1位(合并表当前元素向后移动) \n* - 未合并完的表补表尾 \n* &emsp; 表a剩余元素加到合并表尾部(如果表a有剩余) \n* &emsp; 表b剩余元素加到合并表尾部(如果表b有剩余) \n*/
status_t SeqListMerge(seq_list_t* list_a, seq_list_t* list_b, seq_list_t* merged_list)
{ELEM_TYPE* list_a_cur = list_a->elements;   // list_a_cur指针 -> 顺序表a的elements数组首地址ELEM_TYPE* list_b_cur = list_b->elements;   // list_b_cur指针 -> 顺序表b的elements数组首地址ELEM_TYPE* list_a_last = list_a->elements + list_a->length - 1; // last_a_last指针 -> 顺序表a的elements数组尾地址ELEM_TYPE* list_b_last = list_b->elements + list_b->length - 1; // last_b_last指针 -> 顺序表b的elements数组尾地址// 合并后的表设置属性分配内存merged_list->length = list_a->length + list_b->length;  // 长度merged_list->capacity = list_a->capacity + list_b->capacity;        // 容量merged_list->elements = (ELEM_TYPE*)malloc(merged_list->capacity * sizeof(ELEM_TYPE));  // elements数组分配内存if (!merged_list->elements){return NON_ALLOCATED;   // 分配失败}// 执行合并ELEM_TYPE* merged_list_cur = merged_list->elements; // merged_list_cur指针 -> 合并后的顺序表的elements数组首地址while (list_a_cur <= list_a_last && list_b_cur <=list_b_last){// list_a_cur和list_b_cur指向的两个元素, 选择较小的进入merged_list, 对应的cur指针向后移一位, merged_list_cur向后移一位if (*list_a_cur <= *list_b_cur){*merged_list_cur = *list_a_cur;list_a_cur++;}else{*merged_list_cur = *list_b_cur;list_b_cur++;}merged_list_cur++;}// list_a剩余元素加到merged_list尾部(如果list_a有剩余)while (list_a_cur <= list_a_last){*merged_list_cur = *list_a_cur;merged_list_cur++;list_a_cur++;}// list_b剩余元素加到merged_list尾部(如果list_b有剩余)while (list_b_cur <= list_b_last){*merged_list_cur = *list_b_cur;merged_list_cur++;list_b_cur++;}return OK;
}/*!* @brief **顺序表打印*** @param seq_list 顺序表(指针)* @note* 顺序表打印* ---------* ---------* 循环打印顺序表各元素*/
void SeqListPrint(seq_list_t* seq_list)
{for (int i = 0; i < seq_list->length; i++){printf("%d ", seq_list->elements[i]);}
}
  • main.c
#include <stdio.h>
#include <stdlib.h>
#include "seq_list.h"/*!* @brief **比较函数*** @param item1 **元素1*** @param item2 **元素2*** @return **结果*** @note* 比较函数* -------* -------* **if** 元素1 > 元素2 : \n* &emsp; 返回1 \n* **else if** 元素1 = 元素2 : \n* &emsp; 返回0 \n* **else if** 元素1 < 元素2 : \n* &emsp; 返回-1 \n*/
int compare(ELEM_TYPE item1, ELEM_TYPE item2)
{if (item1 > item2){return 1;}else if (item1 == item2){return 0;}else{return -1;}
}/*!* @brief **测试线性表插入*** @note* 测试线性表插入* ------------* ------------**/
void TestSeqListInsert()
{printf("\n");printf("|------------------------ CyberDash ------------------------|\n");printf("|                       测试顺序表的插入                       |\n");seq_list_t* seq_list = (seq_list_t*)malloc(sizeof(seq_list_t));SeqListInit(seq_list);printf("初始化顺序表sqList完成\n\n");ELEM_TYPE elem1 = 1;ELEM_TYPE elem2 = 2;ELEM_TYPE elem3 = 3;printf("在位置1前边插入elem1: %d\n", elem1);SeqListInsert(seq_list, 1, elem1);printf("在位置2前边插入elem2: %d\n", elem2);SeqListInsert(seq_list, 2, elem2);printf("在位置3前边插入elem3: %d\n", elem3);SeqListInsert(seq_list, 3, elem3);printf("\n打印顺序表sqList:\n");SeqListPrint(seq_list);printf("\n-------------------------------------------------------------\n\n");
}/*!* @brief **测试线性表删除*** @note* 测试线性表删除* ------------* ------------*/
void TestSeqListDelete()
{printf("\n");printf("|------------------------ CyberDash ------------------------|\n");printf("|                       测试顺序表的删除                       |\n");seq_list_t* seq_list = (seq_list_t*)malloc(sizeof(seq_list_t));SeqListInit(seq_list);printf("初始化顺序表sqList完成\n\n");ELEM_TYPE elem1 = 1;ELEM_TYPE elem2 = 3;ELEM_TYPE elem3 = 5;printf("在位置1前边插入elem1: %d\n", elem1);SeqListInsert(seq_list, 1, elem1);printf("在位置2前边插入elem2: %d\n", elem2);SeqListInsert(seq_list, 2, elem2);printf("在位置3前边插入elem3: %d\n", elem3);SeqListInsert(seq_list, 3, elem3);printf("\n删除位置2的元素\n");ELEM_TYPE delete_item;SeqListDelete(seq_list, 2, &delete_item);printf("被删除的元素值: %d\n", delete_item);printf("\n打印顺序表sqList:\n");SeqListPrint(seq_list);printf("\n-------------------------------------------------------------\n\n");
}/*!* @brief **测试线性表查找*** @note* 测试线性表查找* ------------* ------------*/
void TestSeqListLocate()
{printf("\n");printf("|------------------------ CyberDash ------------------------|\n");printf("|                       测试顺序表的查找                      |\n");seq_list_t* seq_list = (seq_list_t*)malloc(sizeof(seq_list_t));SeqListInit(seq_list);printf("初始化顺序表sqList完成\n\n");ELEM_TYPE elem1 = 1;ELEM_TYPE elem2 = 3;ELEM_TYPE elem3 = 5;printf("在位置1前边插入elem1: %d\n", elem1);SeqListInsert(seq_list, 1, elem1);printf("在位置2前边插入elem2: %d\n", elem2);SeqListInsert(seq_list, 2, elem2);printf("在位置3前边插入elem3: %d\n", elem3);SeqListInsert(seq_list, 3, elem3);ELEM_TYPE elem0 = 4;int pos0 = SeqListLocate(seq_list, elem0, compare); // 查找elem0的位置int pos1 = SeqListLocate(seq_list, elem1, compare); // 查找elem1的位置printf("\n");printf("elem0:%d在顺序表中的位置:%d\n", elem0, pos0);   // 位置0表示没有该元素printf("elem1:%d在顺序表中的位置:%d\n", elem1, pos1);printf("\n-------------------------------------------------------------\n\n");
}/*!* @brief **测试线性表合并*** @note* 测试线性表合并* ------------* ------------*/
void TestSeqListMerge()
{printf("\n");printf("|------------------------ CyberDash ------------------------|\n");printf("|                       测试顺序表的合并                       |\n");ELEM_TYPE elements[6] = { 1, 2, 3, 4, 5, 6 };seq_list_t* seq_list_a = (seq_list_t*)malloc(sizeof(seq_list_t));SeqListInit(seq_list_a);seq_list_t* seq_list_b = (seq_list_t*)malloc(sizeof(seq_list_t));SeqListInit(seq_list_b);// 顺序表a插入3个元素SeqListInsert(seq_list_a, 1, elements[0]);SeqListInsert(seq_list_a, 2, elements[2]);SeqListInsert(seq_list_a, 3, elements[4]);// 顺序表b插入3个元素SeqListInsert(seq_list_b, 1, elements[1]);SeqListInsert(seq_list_b, 2, elements[3]);SeqListInsert(seq_list_b, 3, elements[5]);printf("顺序表a: ");SeqListPrint(seq_list_a);printf("\n");printf("顺序表b: ");SeqListPrint(seq_list_a);printf("\n");seq_list_t* merged_list = (seq_list_t*)malloc(sizeof(seq_list_t));SeqListInit(merged_list);SeqListMerge(seq_list_a, seq_list_b, merged_list);printf("合并后的顺序表merged: list: \n");SeqListPrint(merged_list);printf("\n-------------------------------------------------------------\n\n");
}int main()
{printf("你好!顺序表\n");TestSeqListInsert();TestSeqListDelete();TestSeqListLocate();TestSeqListMerge();return 0;
}

运行结果

你好!顺序表|------------------------ CyberDash ------------------------|
|                       测试顺序表的插入                       |
初始化顺序表sqList完成在位置1前边插入elem1: 1
在位置2前边插入elem2: 2
在位置3前边插入elem3: 3打印顺序表sqList:
1 2 3
-------------------------------------------------------------|------------------------ CyberDash ------------------------|
|                       测试顺序表的删除                       |
初始化顺序表sqList完成在位置1前边插入elem1: 1
在位置2前边插入elem2: 3
在位置3前边插入elem3: 5删除位置2的元素
被删除的元素值: 3打印顺序表sqList:
1 5
-------------------------------------------------------------|------------------------ CyberDash ------------------------|
|                       测试顺序表的查找                      |
初始化顺序表sqList完成在位置1前边插入elem1: 1
在位置2前边插入elem2: 3
在位置3前边插入elem3: 5elem0:4在顺序表中的位置:0
elem1:1在顺序表中的位置:1-------------------------------------------------------------|------------------------ CyberDash ------------------------|
|                       测试顺序表的合并                       |
顺序表a: 1 3 5
顺序表b: 1 3 5
合并后的顺序表merged: list:
1 2 3 4 5 6
-------------------------------------------------------------Process returned 0 (0x0)   execution time : 0.099 s
Press any key to continue.

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

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

相关文章

每日三个JAVA经典面试题(三十二)

每日三个JAVA经典面试题(三十二)

1.Mybatis映射文件中&#xff0c;如果A标签通过include引用了B标签的内容&#xff0c;请问&#xff0c;B标签能否定义在A标签的后面&#xff0c;还是说必须定义在A标签的前面&#xff1f; Mybatis的映射文件中&#xff0c;当一个标签&#xff08;如A标签&#xff09;通过<i…
阅读更多...
spring boot admin服务端配置邮件通知、钉钉通知

spring boot admin服务端配置邮件通知、钉钉通知

根据下面的可选项配置邮件 表格 6. 邮件提醒配置的可选项 属性名说明面若防治 spring.boot.admin.notify.mail.enabled 开启邮件提醒 true spring.boot.admin.notify.mail.ignore-changes 要忽略的状态变化&#xff0c;使用逗号分割。格式是: "<from-status>:&l…
阅读更多...
远控桌面多任务并发文件保密传输

远控桌面多任务并发文件保密传输

远程桌面文件传输是一个重要的功能&#xff0c;大多数远控都是用的桌面程序模式&#xff0c;利用系统自带复制粘贴拖拽文件拷贝功能&#xff0c;做一个ole调用对接&#xff0c;可以将很多控制权交给操作系统。 但我做的是浏览器版&#xff0c;浏览器是沙盒原理&#xff0c;为了…
阅读更多...
【2024系统架构设计】案例分析- 5 Web应用

【2024系统架构设计】案例分析- 5 Web应用

目录 一 基础知识 二 真题 一 基础知识 1 Web应用技术分类 大型网站系统架构的演化：高性能、高可用、可维护、应变、安全。 从架构来看：MVC，MVP，MVVM，REST，Webservice，微服务。
阅读更多...
Intel FPGA (6)：dac tlv5618a

Intel FPGA (6)：dac tlv5618a

Intel FPGA (6)&#xff1a;dac tlv5618a 前提摘要 个人说明&#xff1a; 限于时间紧迫以及作者水平有限&#xff0c;本文错误、疏漏之处恐不在少数&#xff0c;恳请读者批评指正。意见请留言或者发送邮件至&#xff1a;“Email:noahpanzzzgmail.com”。本博客的工程文件均存放…
阅读更多...
Cesium 批量种树

Cesium 批量种树

1、准备树种建模 分各种级别建模LOD1-LODN 其中meta.json长这样&#xff1a; Gltf再3Dmax中导出Obj,再通过ObjToGltf的工具转换&#xff0c;参考 https://editor.csdn.net/md/?articleId96484597 2、准备shp点数据。&#xff08;shp中的点位就是种树的位置&#xff09; 3、准…
阅读更多...
简单的HTML

简单的HTML

1.HTML介绍 HTML(HyperText Markup Language,超文本标记语言)是用于创建网页的标准标记语言。它使用一系列的元素来描述网页的结构和内容,包括文本、图像、链接、表格等。 1.1HTML基础结构 HTML文件是一种纯文本文件,由一系列的元素构成。每个元素由一对尖括号<>包围,…
阅读更多...
R语言技能 | 不同数据类型的转换

R语言技能 | 不同数据类型的转换

原文链接&#xff1a;R语言技能 | 不同数据类型的转换 本期教程 写在前面 今天是4月份的第一天&#xff0c;再过2天后再一次迎来清明小假期。木鸡大家是否正常放假呢&#xff1f; 我们在使用R语言做数据分析时&#xff0c;会一直对数据进行不同类型的转换&#xff0c;有时候…
阅读更多...
Pytorch实用教程： torch.tensor()的用法

Pytorch实用教程： torch.tensor()的用法

在PyTorch中&#xff0c;torch.tensor()函数是用来创建张量&#xff08;Tensor&#xff09;的一个非常基础和重要的函数。张量是PyTorch中的基本数据结构&#xff0c;用于存储和操作数据&#xff0c;可以看作是一个高维数组。torch.tensor()函数可以从数据创建新的张量&#xf…
阅读更多...
String Encryptor custom Bean not found with name ‘jasyptStringEncryptor‘...

String Encryptor custom Bean not found with name ‘jasyptStringEncryptor‘...

项目采用 spring boot 2.6.13 jasypt-spring-boot-starter 3.0.5 apollo-client 1.6.0 自定义jasyptStringEncryptor&#xff0c;服务器上启动死活报找不到bean jasyptStringEncryptor&#xff0c;采用默认的&#xff0c;密文配置项自然解密失败导致服务无法启动。 经过一…
阅读更多...
海康Ehome2.0与5.0设备接入EasyCVR视频汇聚平台时的配置区别

海康Ehome2.0与5.0设备接入EasyCVR视频汇聚平台时的配置区别

安防视频监控/视频集中存储/云存储/磁盘阵列EasyCVR平台可拓展性强、视频能力灵活、部署轻快&#xff0c;可支持的主流标准协议有国标GB28181、RTSP/Onvif、RTMP等&#xff0c;以及支持厂家私有协议与SDK接入&#xff0c;包括海康Ehome、海大宇等设备的SDK等。平台既具备传统安…
阅读更多...
LeetCode热题Hot100 - 最长回文子串

LeetCode热题Hot100 - 最长回文子串

一刷 给你一个字符串 s&#xff0c;找到 s 中最长的回文子串。 如果字符串的反序与原始字符串相同&#xff0c;则该字符串称为回文字符串。 思路&#xff1a; 返回最长回文子串&#xff0c;用maxl、maxr记录最长回文子串的起始和终点位置即可。 二维数组&#xff0c;dp[i][j]…
阅读更多...
【AI+编程】AI工具（通义灵码）编写yaml转换properties工具类思考

【AI+编程】AI工具（通义灵码）编写yaml转换properties工具类思考

需求背景&#xff1a;由于公司安装的apollo比较老&#xff0c;虽然新版本已经支持yaml格式了&#xff0c;但升级apollo代价比较大&#xff0c;有个项目配置文件之前放在项目里基于yaml编写的&#xff0c;最近想切换到apollo存储配置文件。 先百度了下&#xff0c;找了一个在线…
阅读更多...
plasmo内容UI组件层级过高导致页面展示错乱

plasmo内容UI组件层级过高导致页面展示错乱

我使用plasmo写了一个行内样式的UI组件&#xff0c;但是放到页面上之后&#xff0c;会和下拉组件出现层级错乱&#xff0c;看了一下样式&#xff0c;吓我一跳&#xff1a;层级竟然设置的如此之高 所以就需要将层级设置低一点&#xff1a; #plasmo-shadow-container {z-index: …
阅读更多...
使用node更加方便的操作mysql数据库的小工具

使用node更加方便的操作mysql数据库的小工具

这是一个自己封装的小工具,能够更加方便的操作数据库 地址: 工具首页 git仓库地址 功能还在继续开发当中… 安装 npm install mysqinfo已经引入mysql工具包,无需在项目中再次引入mysql工具包 导入 const db require(mysqinfo)获取数据库对象 // db.dbconnect(mysql地址,mys…
阅读更多...
HTTPS ECDHE 握手解析（计算机网络）

HTTPS ECDHE 握手解析（计算机网络）

使用了 ECDHE&#xff0c;在 TLS 第四次握手前&#xff0c;客户端就已经发送了加密的 HTTP 数据&#xff0c;而对于 RSA 握手过程&#xff0c;必须要完成 TLS 四次握手&#xff0c;才能传输应用数据。 所以&#xff0c;ECDHE 相比 RSA 握手过程省去了一个消息往返的时间&#…
阅读更多...
【计算机网络】select/poll

【计算机网络】select/poll

多路转接 - select/poll 一、I/O 多路转接之 select1. select 接口2. select 的使用3. select 的优缺点 二、I/O 多路转接之 poll1. poll 接口2. poll 的使用3. poll 与 select 的对比 一、I/O 多路转接之 select 多路转接属于 IO 复用方式的一种。系统提供 select() 函数来实…
阅读更多...
Pinia的数据持久化

Pinia的数据持久化

Pinia的数据持久化可以通过多种方式实现&#xff0c;例如使用vuex-persistedstate插件或专门为Pinia设计的插件如pinia-plugin-persist。下面我将通过一个简单的例子来说明如何使用Pinia及其数据持久化功能。 假设我们有一个简单的Vue 3应用程序&#xff0c;其中包含一个用户模…
阅读更多...
309_C++_QT中string类型打印、显示中文乱码，将宽字符串转换为UTF-8字符串此贴完美解决，CSDN上好多都不行无法转换

309_C++_QT中string类型打印、显示中文乱码，将宽字符串转换为UTF-8字符串此贴完美解决，CSDN上好多都不行无法转换

std::string fileName(ent->d_name);std::string strtring = AnsiToUtf8(fileName);#include <dirent.h> #
阅读更多...
R语言，数据类型转换

R语言，数据类型转换

原文链接&#xff1a;R语言技能 | 不同数据类型的转换 本期教程 写在前面 今天是4月份的第一天&#xff0c;再过2天后再一次迎来清明小假期。木鸡大家是否正常放假呢&#xff1f; 我们在使用R语言做数据分析时&#xff0c;会一直对数据进行不同类型的转换&#xff0c;有时候…
阅读更多...
最新文章

Copyright @ 2022~2023