C语言---数据结构实验---顺序表的合并---链表的基本操作---重点解析约瑟夫问题

news2024/11/28 8:26:02

文章目录

  • 顺序表的合并
    • 代码实现
    • 代码下载
  • 链表的基本操作
    • 代码实现
    • 代码下载
  • 约瑟夫问题
    • 问题分析
    • 代码实现

本篇展示数据结构的两个实验

其中，重点分析约瑟夫问题

实验中代码的命名风格等均与下方博客风格类似，全程手撕图解

对顺序表和链表不清楚有以下文章介绍

手撕顺序表
手撕单链表

掌握顺序表和单链表后 实验均为上述的简单应用

顺序表的合并

定义线性表的顺序存储结构，并使用定义的结构实现两个线性表的合并。（建立两个有序顺序表，将两个有序顺序表合并为一个有序顺序表）。
内容要求：
建立有序表：12，23，46，67，85
建立有序表：5，59，94
两个有序顺序表合并为一个有序顺序表，验证代码的正确性。

代码实现

//建立有序表：12，23，46，67，85
//建立有序表：5，59，94
//两个有序顺序表合并为一个有序顺序表，验证代码的正确性。

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* a;
	int size;
	int capacity;
}SeqList;

void SListInit(SeqList* ps)
{
	//assert(ps);
	ps->size = 0;
	ps->capacity = 4;
	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		return;
	}
}

void SListDestroy(SeqList* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->size = 0;
}

void SListCheckCapacity(SeqList* ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		SLDataType* tmp = NULL;
		tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType)*(ps->capacity) * 2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
		ps->capacity *= 2;
		//printf("The capacity now:%d\n", ps->capacity);
	}
	else
	{
		return;
	}
}

void SListPushBack(SeqList* ps, SLDataType x)
{
	assert(ps);
	SListCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}

void SListPrint(SeqList* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

void SListMerge(SeqList* ps1, SeqList* ps2)
{
	assert(ps1);
	assert(ps2);
	SeqList ps;
	SListInit(&ps);
	for (int i = 0; i < ps1->size; i++)
	{
		SListPushBack(&ps, ps1->a[i]);
	}
	for (int i = 0; i < ps2->size; i++)
	{
		SListPushBack(&ps, ps2->a[i]);
	}
	printf("The result of merging two seqlists is:\n");
	SListPrint(&ps);
}

int main()
{
	SeqList ps1;
	SeqList ps2;
	SListInit(&ps1);
	SListInit(&ps2);
	int quantity1 = 0, quantity2 = 0, input = 0;

	printf("Input quantity of seqlist1-> ");
	scanf("%d", &quantity1);
	for (int i = 0; i < quantity1; i++)
	{
		scanf("%d", &input);
		SListPushBack(&ps1, input);
	}

	printf("Input quantity of seqlist2-> ");
	scanf("%d", &quantity2);
	for (int i = 0; i < quantity2; i++)
	{
		scanf("%d", &input);
		SListPushBack(&ps2, input);
	}

	SListMerge(&ps1, &ps2);
	return 0;
}

代码下载

Gitee下载链接

链表的基本操作

定义线性表的链式存储结构，定义结点类型，并使用定义的结构实现链表的创建，插入，删除、查询、输出等基本操作。
通讯录管理（必做内容） ； 约瑟夫环（选做内容）
必做内容要求：
1.通讯者的结点类型定义如下：
typedef struct {
char num[5] ; //编号
char name[9] ; //姓名
char sex[3] ; //性别
char phone[13]; //电话
char addr[31] ; //地址
]DataType ;
2.线性表的链式存储结构定义如下：
typedef struct node { //结点类型定义
DataType data ; //结点数据域
struct node * next ; //结点指针域
} ListNode ;
typedef ListNode * LinkList ;
ListNode * p ; //定义一个指向结点的指针变量
LinkList head ; //定义指向单链表的头指针
3.主控菜单设计要求
程序运行后，给出6个菜单项的内容和输入提示：

  1. 通讯录链表的建立
  2. 通讯者结点的插入
  3. 通讯者结点的查询
  4. 通讯者结点的删除
  5. 通讯录链表的输出
  6. 退出管理系统
    请选择 0——5
    使用数字0——5来选择菜单项，其他输入则不起作用。

选做内容要求：
约瑟夫（Joseph）问题的一种描述是：30个旅客同乘一条船，因为严重超载，加上风高浪大，危险万分。因此船长告诉乘客，只有将全船一半的旅客投入海中，其余人才能幸免于难。无奈，大家只好同意这种办法，并议定30个人围成一圈，由第一个人数起，依次报数，数到第9人，便把他投入大海，然后再从他的下一个人数起，数到第9人，再将他扔进大海中，如此循环地进行，直到剩下15个乘客为止。问哪些位置是将被扔下大海的位置？

1.利用单向循环链表存储结构模拟此过程，按照出列的顺序输出各人的编号。
2.为了不失一般性，将30改为一个任意输入的正整数n，而报数上限（原为9）也为一个任选的正整数k。这样该算法描述如下：
（1）创建含有n个结点的单循环链表；
（2）生者与死者的选择：
p指向链表第一个结点，初始i 置为1；
while (i<=n/2) //删除一半的结点
{ 从p指向的结点沿链前进k-1步；
删除第k个结点（q所指向的结点）；p指向q的下一个结点；
输出其位置q->data；
i自增1；
}
（3）输出所有生者的位置。

3.测试结果
对于总人数30，报数上限为9，则
死者编号为：9，18，27，6，16，26，7，19，30，12，24，8，22，5，23
生者编号为：1，2，3，4，10，11，13，14，15，17，20，21，25，28，29

代码实现

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <stdbool.h>

typedef  struct
{
	char  num[5];    //编号
	char  name[9];   //姓名
	char  sex[3];     //性别
	char  phone[13];  //电话
	char  addr[31];   //地址
}DataType;

typedef struct node
{
	DataType data;
	struct node* next;
}ListNode;

//头节点用head
//定义一个指向结点的指针变量 ListNode* p;

ListNode* BuyListNode(DataType x);

void ListNodePush(ListNode** phead);

DataType Buynewdata();

void ListNodePrint(ListNode** phead);

int ListNodeFind(ListNode* head, const char* Findname);

void ListNodePop(ListNode** phead, const char* Popname);

ListNode* BuyListNode(DataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->next = NULL;
	newnode->data = x;
	return newnode;
}

DataType Buynewdata()
{
	DataType newdata;
	printf("请依次输入编号 姓名 性别 电话 地址\n");
	scanf("%s %s %s %s %s",
		newdata.num, newdata.name, newdata.sex, newdata.phone, newdata.addr);
	return  newdata;
}

void ListNodePush(ListNode** phead)
{
	assert(phead);
	ListNode* newnode = BuyListNode(Buynewdata());
	if (*phead == NULL)
	{
		*phead = newnode;
	}
	else
	{
		newnode->next = *phead;
		*phead = newnode;
	}
}

void ListNodePrint(ListNode** phead)
{
	ListNode* cur = *phead;
	printf("%-5s%-10s%-8s%-13s%-31s\n",
		"编号", "姓名", "性别", "电话", "地址");
	while (cur)
	{
		printf("%-5s%-10s%-8s%-13s%-31s\n",
			cur->data.num, cur->data.name, cur->data.sex,
			cur->data.phone, cur->data.addr);
		cur = cur->next;
	}
}

int ListNodeFind(ListNode* head, const char* Findname)
{
	ListNode* cur = head;
	while (cur)
	{
		if (strcmp(Findname, cur->data.name) == 0)
		{
			printf("找到了,该人的信息如下\n");
			printf("%-5s%-10s%-8s%-13s%-31s\n",
				"编号", "姓名", "性别", "电话", "地址");
			printf("%-5s%-10s%-8s%-13s%-31s\n",
				cur->data.num, cur->data.name, cur->data.sex,
				cur->data.phone, cur->data.addr);
			return 1;
		}
		else
		{
			cur = cur->next;
		}
	}
	printf("找不到信息\n");
	return 0;
}

void ListNodePop(ListNode** phead, const char* Popname)
{
	assert(*phead);
	assert(phead);
	if (ListNodeFind(*phead, Popname))
	{
		ListNode* Findnode = *phead;
		ListNode* prev = *phead;
		while (strcmp(Findnode->data.name, Popname) != 0)
		{
			prev = Findnode;
			Findnode = Findnode->next;
		}
		prev->next = Findnode->next;
		free(Findnode);
		Findnode = NULL;
		printf("删除该人信息成功\n");
		return;
	}
	else
	{
		printf("找不到该人信息\n");
		return;
	}
}

void menu()
{
	printf("*********************************************\n");
	printf("****1.建立信息表************** 2.插入信息 ****\n");
	printf("****3.查询信息  ************** 4.删除信息 ****\n");
	printf("****5.打印信息  ************** 0.退出     ****\n");
	printf("*********************************************\n");
}

void SetupListNode(ListNode** phead)
{
	int num = 0;
	printf("建立链表成功，开始录入信息\n");
	printf("输入要录取信息的个数->");
	scanf("%d", &num);
	while (num--)
	{
		ListNodePush(phead);
	}
}

void FindFunction(ListNode* head)
{
	char Findname[20] = { 0 };
	printf("输入要查找的人名");
	scanf("%s", Findname);
	ListNodeFind(head, Findname);
}

void PopFunction(ListNode** phead)
{
	char Popname[20] = { 0 };
	printf("输入要查找的人名");
	scanf("%s", Popname);
	ListNodePop(phead, Popname);
}

int main()
{
	menu();
	int input = 0;
	ListNode* head = NULL;
	do
	{
		printf("请选择->");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			SetupListNode(&head);
			break;
		case 2:
			if (head == NULL)
			{
				printf("通讯录还未建立，请先建立\n");
				break;
			}
			else
			{
				ListNodePush(&head);
				break;
			}
		case 3:
			if (head == NULL)
			{
				printf("通讯录还未建立，请先建立\n");
				break;
			}
			else
			{
				FindFunction(head);
				break;
			}
		case 4:
			if (head == NULL)
			{
				printf("通讯录还未建立，请先建立\n");
				break;
			}
			else
			{
				PopFunction(&head);
				break;
			}
		case 5:
			if (head == NULL)
			{
				printf("通讯录还未建立，请先建立\n");
				break;
			}
			else
			{
				ListNodePrint(&head);
				break;
			}
		case 0:
			break;
		default:
			printf("请重新选择\n");
			break;
		}
		menu();
	} while (input);
	return 0;
}

代码下载

Gitee下载链接

约瑟夫问题

问题分析

约瑟夫（Joseph）问题的一种描述是：30个旅客同乘一条船，因为严重超载，加上风高浪大，危险万分。因此船长告诉乘客，只有将全船一半的旅客投入海中，其余人才能幸免于难。无奈，大家只好同意这种办法，并议定30个人围成一圈，由第一个人数起，依次报数，数到第9人，便把他投入大海，然后再从他的下一个人数起，数到第9人，再将他扔进大海中，如此循环地进行，直到剩下15个乘客为止。问哪些位置是将被扔下大海的位置？

  1. 利用单向循环链表存储结构模拟此过程，按照出列的顺序输出各人的编号。
  2. 为了不失一般性，将30改为一个任意输入的正整数n，而报数上限（原为9）也为一个任选的正整数k。这样该算法描述如下：
（1） 创建含有n个结点的单循环链表；

（2） 生者与死者的选择：

p指向链表第一个结点，初始i 置为1；

while (i<=n/2)   //删除一半的结点

{  
从p指向的结点沿链前进k-1步；

删除第k个结点（q所指向的结点）；

p指向q的下一个结点；

输出其位置q->data；

i自增1；
}

（3） 输出所有生者的位置。
  1. 测试结果
    对于总人数30，报数上限为9，则
    死者编号为：9，18，27，6，16，26，7，19，30，12，24，8，22，5，23
    生者编号为：1，2，3，4，10，11，13，14，15，17，20，21，25，28，29

传统的约瑟夫问题可以采用循环数组来解决，在前面介绍vector中就提及过利用循环数组解决约瑟夫问题，那么这里题目要求我们用链表来解决这个问题

那么现在整个流程就分为这么几个阶段，首先要搭建好链表，其次将数据插入进链表中，再把所求元素删除链表外，最后将链表输出即可

整个流程中需要注意的有下面几个问题

1. 要解决循环链表问题

通过画图就能知道，每次要让尾节点指向头，每次插入后都需要找到尾节点，改变尾节点的指向

在这里插入图片描述
2. 要解决如何找到要删元素的问题

首先说明思路：思路就是把定义一个cur指针，这个指针用来指向要删除的节点，这个思路本身是没有问题的，但是问题在于在实现代码过程中出现了问题

第一个问题在于cur在找要删除元素的过程中是需要经过cur=cur->next，问题就在于循环几次
这个题的要求是删15个元素，每次报到9就删除，因此实际上cur只需要循环8次就能推进到9的位置

第二个问题是删除元素后导致前后不一致的问题，删除元素后如果未对cur节点进行处理，那么cur元素当前位置和最初始的位置实际上是不一样的，假设链表元素是1，2，3…依次排序，那么cur又开始指向1，经过遍历，现在要删除的是元素9，删除掉元素9后，实际上应该对cur再推进一次，这样cur才能指向初始位置的"1"

解决这两个问题后续过程就很简单了，这里代码并没有提前进行宏定义，后续需要进行改变直接进行修改数据即可

代码实现

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
}ListNode;

void ListNodePush(ListNode** phead,LTDataType x)
{
	assert(phead);
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;

	if (*phead == NULL)
	{
		*phead = newnode;
		newnode->next = newnode;
	}
	else
	{
		ListNode* tail = *phead;
		while (tail->next != *phead)
		{
			tail = tail->next;
		}
		newnode->next = *phead;
		*phead = newnode;
		tail->next = *phead;
	}
}

void ListNodePop(ListNode** phead,ListNode* cur)
{
	ListNode* prev = *phead;
	ListNode* next = *phead;
	while (prev->next != cur)
	{
		prev = prev->next;
	}
	next = cur->next;
	prev->next = next;
	//free(cur);
	//cur = NULL;
}

void ListNodePrint(ListNode* head)
{
	assert(head);
	ListNode* cur = head->next;
	printf("%d->", head->data);
	while (cur!=head)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
}

int main()
{
	ListNode* plist = NULL;
	for (int i = 30; i > 0; i--)
	{
		ListNodePush(&plist, i);
	}
	int a = 15;
	ListNode* cur = plist;
	while (a--)
	{
		for (int i = 0; i < 8; i++)
		{
			cur = cur->next;
		}
		ListNodePop(&plist, cur);
		cur = cur->next;
	}
	ListNodePrint(plist);
	return 0;
}

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

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

相关文章

平衡小车学习教程2(软件篇)——MPU6050数据读取欧拉角，移植DMP读取Roll角、Pitch角、Yaw角

平衡小车学习教程2(软件篇)——MPU6050数据读取欧拉角，移植DMP读取Roll角、Pitch角、Yaw角

前言 上一篇&#xff0c;给大家介绍了平衡小车的硬件资源及其小车底层硬件介绍篇 平衡小车学习教程1——硬件资源及其小车底层硬件介绍篇 这篇来教大家如何快速的使用MPU6050自带的DMP库读取陀螺仪数据&#xff0c;读取翻滚角(Roll)、俯仰角(Pitch)、航向角(Yaw)这三个角的数…
阅读更多...
卖家如何做好独立站？这些要点要牢记！

卖家如何做好独立站？这些要点要牢记！

随着跨境电商第三方平台的竞争压力越来越大&#xff0c;以及平台流量红利期迎来大幅缩水&#xff0c;使得越来越多的跨境卖家开始另寻出路&#xff0c;建设自己的品牌。而独立站的优势特点&#xff0c;在当下的市场竞争环境中优势更为突出&#xff0c;这也使得众多卖家涌入独立…
阅读更多...
05-MySQL-基础篇-SQL之DQL语句

05-MySQL-基础篇-SQL之DQL语句

SQL之DQL语句 前言DQL准备数据基础语法基本查询条件查询集合函数分组查询排序查询分页查询执行顺序 前言 本篇来学习下SQL中的DQL语句 DQL 英文全称是Data Query Language(数据查询语言)&#xff0c;数据查询语言&#xff0c;用来查询数据库中表的记录。 准备数据 # 删除表…
阅读更多...
Spring框架概述及核心设计思想

Spring框架概述及核心设计思想

文章目录 一. Spring框架概述1. 什么是Spring框架2. 为什么要学习框架&#xff1f;3. Spring框架学习的难点 二. Spring核心设计思想1. 容器是什么&#xff1f;2. IoC是什么&#xff1f;3. Spring是IoC容器4. DI&#xff08;依赖注入&#xff09; 一. Spring框架概述 1. 什么是…
阅读更多...
芜湖，埋点还可以这么做？这也太简单了

芜湖，埋点还可以这么做？这也太简单了

目录 前言 一个埋点的Demo 安装依赖 添加测试代码 编写入口文件 编写插件 运行Demo 处理_tracker的import 改进 给其他的函数类型添加埋点 处理埋点函数变量名 总结&#xff1a; 前言 在项目开发中通常会有埋点的需求&#xff0c;然而当项目过于庞大&#xff0c;给…
阅读更多...
聚焦型光场相机基于立体视差的深度估计原理

聚焦型光场相机基于立体视差的深度估计原理

聚焦型光场相机可以看作是主透镜将物面成了一个放大或者缩小的虚像&#xff0c;然后每个微透镜阵列对这个经过放大或者缩小的虚像进行二次成像后投影在了ccd平面&#xff0c;其中二次成像的过程可以比拟为一个虚拟阵列相机&#xff0c;利用MLA和主透镜的相关参数就可以以立体视…
阅读更多...
Java开发基础系列(三):数据操作

Java开发基础系列(三):数据操作

&#x1f60a; 作者&#xff1a; 一恍过去 &#x1f496; 主页&#xff1a; https://blog.csdn.net/zhuocailing3390 &#x1f38a; 社区&#xff1a; Java技术栈交流 &#x1f389; 主题&#xff1a; Java开发基础系列(三):数据操作 ⏱️ 创作时间&#xff1a; 2023年07月…
阅读更多...
Java线程池实现原理

Java线程池实现原理

随着计算机行业的飞速发展&#xff0c;摩尔定律逐渐失效&#xff0c;多核CPU成为主流。使用多线程并行计算逐渐成为开发人员提升服务器性能的基本武器。J.U.C提供的线程池&#xff1a;ThreadPoolExecutor类&#xff0c;帮助开发人员管理线程并方便地执行并行任务。了解并合理使…
阅读更多...
x86架构ubuntu22下运行3DS模拟器Citra

x86架构ubuntu22下运行3DS模拟器Citra

0. 环境 i5 ubuntu22&#xff08;安装系统时候选择 自动上网下载第三方驱动软件&#xff0c;主要是显卡驱动opengl&#xff09; 1. apt安装依赖 1.1 SDL2 sudo apt install libsdl2-dev 1.2 OpenSSL (optional) sudo apt install libssl-dev 1.3 Qt 6.2 sudo apt install …
阅读更多...
零基础学Python-必备工具安装

零基础学Python-必备工具安装

文章目录 1. Python 安装与卸载Python 安装包下载安装Python如何验证Python 安装成功扩展 电脑中其实可以装多个不同版本的python 卸载Python 2. Python 开发有哪些常用的IDEPyCharm 安装PyCharm 安装包下载安装PyCharm PyCharm 使用VScode 安装VScode 安装包下载安装VScodeVsc…
阅读更多...
libbpf-bootstrap开发指南：网络包监测-tc

libbpf-bootstrap开发指南：网络包监测-tc

目录 前置知识 代码分析 BPF部分 功能说明 struct __sk_buff 说明 bpf_htons & bpf_ntohs 为什么有l2 1、l31 data 数据的排布 用户部分 功能说明 DECLARE_LIBBPF_OPTS 执行效果 前置知识 IP数据包的总长度指的是整个IP数据包的长度&#xff0c;包括IP头部和…
阅读更多...
React(2)

React(2)

题外话&#xff1a;vscode有个插件可以很方便的快速写代码 输入rcc回车 1.组件嵌套 import React, { Component } from reactclass Navbar extends Component{render(){return <div>Navbar</div>} }const Swiper()>{return <div>Swiper</div> }cons…
阅读更多...
学习babylon.js --- [2] 项目工程搭建

学习babylon.js --- [2] 项目工程搭建

本文讲述如何搭建babylonjs的项目工程。 一 准备 首先创建一个目录叫MyProject&#xff0c;然后在这个目录里再创建三个目录&#xff1a;dist&#xff0c;public和src&#xff0c;如下&#xff0c; 接着在src目录里添加一个文件叫app.ts&#xff0c;本文使用typescript&#…
阅读更多...
论文笔记--PTR: Prompt Tuning with Rules for Text Classification

论文笔记--PTR: Prompt Tuning with Rules for Text Classification

论文笔记--PTR: Prompt Tuning with Rules for Text Classification 1. 文章简介2. 文章概括3 文章重点技术3.1 Pre-training & Fine-tuning & Prompt-based Fine Tuning3.2 PTR(Prompt Tuning with Rules)3.3 task decomposition3.4 Sub-prompts composition3.5 多个l…
阅读更多...
平衡二叉搜索树--AVL详解剖析

平衡二叉搜索树--AVL详解剖析

目录 一、什么是AVL树 二、AVL树的作用 三、树节点的定义 四、节点的插入 五、旋转 1.左单旋 2.右单旋 左右双旋代码 &#xff1a; 4.右左双旋 一、什么是AVL树 AVL树就是二叉搜索树的进一步的优化&#xff0c;二叉搜索树虽可以缩短查找的效率&#xff0c;但是当数据有…
阅读更多...
SDN系统方法 | 1. 概述

SDN系统方法 | 1. 概述

随着互联网和数据中心流量的爆炸式增长&#xff0c;SDN已经逐步取代静态路由交换设备成为构建网络的主流方式&#xff0c;本系列是免费电子书《Software-Defined Networks: A Systems Approach》的中文版&#xff0c;完整介绍了SDN的概念、原理、架构和实现方式。原文: Softwar…
阅读更多...
SpringFactoriesLoader解析

SpringFactoriesLoader解析

一、SpringFactoriesLoader 介绍 1.1 SpringFactoriesLoader 简介 SpringFactoriesLoader 工厂加载机制是 Spring 内部提供的一个约定俗成的加载方式&#xff0c;与 java spi 类似&#xff0c;只需要在模块的 META-INF/spring.factories 文件中&#xff0c;以 Properties 类型…
阅读更多...
DOT slam论文翻译

DOT slam论文翻译

DOT:视觉SLAM的动态目标跟踪 摘要 - 在本文中&#xff0c;我们提出了DOT(动态目标跟踪)&#xff0c;这是一个添加到现有SLAM系统中的前端&#xff0c;可以显着提高其在高动态环境中的鲁棒性和准确性。DOT结合实例分割和多视图几何来生成动态对象的掩模&#xff0c;以允许基于刚…
阅读更多...
实现 Rollup 插件alias 并使用单元测试提高开发效率

实现 Rollup 插件alias 并使用单元测试提高开发效率

本篇文章是对 实现 Rollup 插件 alias | 使用 TypeScript 实现库的基本流程 | 使用单元测试提高开发效率 的总结。其中涉及到开发一个组件库的诸多知识点。 实现一个经常用的 rollup 插件 alias 首先执行npm init命令初始化一个package.json文件&#xff0c;因为插件使用了ty…
阅读更多...
DevOps系列文章之Argo CD 使用

DevOps系列文章之Argo CD 使用

一、什么是 argo cd Argo CD 是用于 Kubernetes 的声明性 GitOps 连续交付工具。 二、为什么使用 argo cd Argo CD 可在指定的目标环境中自动部署所需的应用程序状态&#xff0c;应用程序部署可以在 Git 提交时跟踪对分支&#xff0c;标签的更新&#xff0c;或固定到清单的特…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023