【数据结构】——单链表（增删查改）

news2024/11/19 5:53:18

 

目录

前言：

一：单链表的特点

​编辑 二：单链表实现

单链表定义

2.1申请节点（初始化）

2.2单链表尾插 

​编辑 2.3单链表打印

2.4单链表头插

 2.5单链表尾删

2.6单链表头删

 2.7单链表查找

2.8在目标位置后面插入

 2.9删除目标位置后面的值

 2.10在目标位置前插入

2.11删除目标位置

2.12单链表销毁

总代码

test.c

SList.c

SList.h 

前言：

因为顺序进行插入删除时，有时候需要移动大量数据，造成不便，影响了运行效率。这时候引出了它的黄金搭档 单链表；

单链表：通过一组任意的存储单元来存储线性表中的数据元素，不需要使用地址连续的存储单元，因此它不要求在逻辑上相邻的两个元素在物理位置上也相邻。

一：单链表的特点

  1. 单链表不要求逻辑上相邻的两个元素在物理位置上也相邻，因此不需要连续的存储空间。
  2. 单链表是非随机的存储结构，即不能直接找到表中某个特定的结点。查找某个特定的结点时，需要从表头开始遍历，依次查找。
  3. 优点：支持动态内存分配。由于单链表不需要预先分配一段连续的空间，因此可以根据实际需求动态地申请、释放节点空间，避免浪费内存。支持高效的插入、删除操作。由于单链表中的节点是通过指针相连的，因此在插入、删除一个节点时，只需要修改其前驱节点或后继节点的指针即可，时间复杂度为O ( 1 )
  4. 缺点：不支持随机访问。由于单链表中的节点不是连续存储的，因此不能像数组一样通过下标来直接访问一个元素，需要从头节点开始遍历整个链表才能访问任意位置的元素。

 二：单链表实现

单链表定义

每个链表结点，除了存放元素自身的信息外，还需要存放一个指向其后继的指针

单链表功能实现中，需要考虑三种情况：链表为空，一个节点，多个节点

typedef int SLNDatatype;

typedef struct SListNode //定义单链表结点类型
{
	struct SListNode* next;    //数据域，可以是别的各种数据类型
	SLNDatatype val;    //指针域

}SLNode;

2.1申请节点（初始化）

malloc出来一块地址，将有效值赋给val，next给NULL

malloc动态开辟的地址，在程序结束前，都需要进行free释放；

然会该节点的地址

//申请一个节点
SLNode* CreateNode(SLNDatatype x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->val = x;
	newnode->next = NULL;
	return newnode;
}

2.2单链表尾插 

我们需要改变该链表，传的是地址，形参接受应该为二级指针；

单链表功能实现中，需要考虑三种情况：链表为空，一个节点，多个节点

如果是空，直接将新节点赋给第一个节点

如果是一个及以上节点，找到链表尾部后，指针域next链接新节点数据域data

// 单链表尾插
void SListPushBack(SLNode** pplist, SLNDatatype x)
{
	assert(pplist);
	SLNode* newnode = CreateNode(x);

	if (*pplist == NULL)
	{
		*pplist = newnode;
	}
	else
	{
		//找尾
		SLNode* tail = *pplist;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

 2.3单链表打印

在【C】系列中，讲过结构体不管是修改还是打印，最好都传地址来操作，这样不需要额外开辟空间

assert（）：

断言判断中，其实pplist这个不会为NULL，因为*pplist是地址，哪怕这个地址指向的也是NULL，但是该pplist不为NULL；

assert（）：

断言是判断不允许为NULL的情况，比如链表为空，还要删除的这类情况；

在打印中：

将下一个地址赋给当前地址，进行遍历操作，和之前的自增++这类不同，因为链表空间不是连续存放的

//打印单链表
void SListPrint(SLNode** pplist)
{
	assert(pplist);
	SLNode* cur = *pplist;
	//遍历打印
	while (cur)
	{
		printf("%d->", cur->val);
		cur = cur->next;
	}
	printf("NULL\n");
}

2.4单链表头插

头部插入不管是空链表还是多个节点，将新链表链接到第一个节点即可

// 单链表的头插
void SListPushFront(SLNode** pplist, SLNDatatype x)
{
	assert(pplist);
	SLNode* phead = *pplist;
	SLNode* newnode = CreateNode(x);

	newnode->next = *pplist;
	*pplist = newnode;
}

 

 2.5单链表尾删

需要考虑两种情况

一个节点：将该节点删除释放即可；

两个及以上节点：循环找到下下个节点为空的节点，将其删除释放；

        也可以定义一个指针 prev:该指针作用是 当cur的下一个节点不等于空时， 记录此位置，如此循环直到找到下一个节点为空，将其cur释放删除，再将prev定义为新的尾，next置NULL；

// 单链表的尾删
void SListPopBack(SLNode** pplist)
{
	assert(pplist);
	assert(*pplist);
	SLNode* cur = *pplist;

	//1.一个节点
	if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	//2.一个以上的节点
	else
	{

        // 找尾

		/*SLNode* prev = NULL;
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}

		free(tail);
		tail = NULL;

		prev->next = NULL;*/


		while (cur->next->next != NULL)
		{
			cur = cur->next;
		}
		free(cur->next);
		cur->next = NULL;
	}
}

 

2.6单链表头删

检查断言后，记录第一个节点位置，将第二个节点赋给第一个节点，再释放记录的位置；

可满足一个节点和多个节点

// 单链表头删
void SListPopFront(SLNode** pplist)
{
	assert(pplist);
	assert(*pplist);
	
	SLNode* cur = *pplist;
	*pplist = (*pplist)->next;
	free(cur);
	cur = NULL;
}

 

 2.7单链表查找

查找单链表是否存在此val，存在返回该指针，不存在返回null;

需要注意的是返回的是该指针，而不是该值；后面功能用指针传递更好，在C++库中也是这样定义的，我们可以统一

// 单链表查找
SLNode* SListFind(SLNode* plist, SLNDatatype x)
{
	assert(plist);

	SLNode* cur= plist;
	while (cur)	//遍历查找
	{	
		if (cur->val == x)
		{
			return cur;
		}
		else
		{
			cur= cur->next;
		}
	}
	return NULL;
}

2.8在目标位置后面插入

创建新节点空间后，将newnode链接到原链表尾，这里需要顺序关系，先链接尾部，再将newnode地址链接到原链表尾部


// 单链表在pos位置之后插入x
void SListInsertAfter(SLNode* pos, SLNDatatype x)
{
	assert(pos);
	SLNode* newnode = CreateNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

 

 2.9删除目标位置后面的值

删除pos后面，将pos的next记录，再将链表跨过链接，释放记录值

// 单链表删除pos位置之后的值
void SListEraseAfter(SLNode* pos)
{
	assert(pos);
	pos位置后还有两个及以上值
	//if (pos->next->next != NULL)
	//{
	//	SLNode* cur = pos->next;	//cur是要删除的位置
	//	SLNode * next = pos->next->next;	//pos链接下一个位置
	//	
	//	pos->next = next;
	//	free(cur);
	//	cur = NULL;
	//}
	pos位置后只有一个或者没有值
	//else
	//{
	//	free(pos->next);
	//	pos->next = NULL;
	//}

	SLNode* cur = pos->next;
	pos->next = pos->next->next;
	free(cur);
	cur = NULL;

}

 

 2.10在目标位置前插入

精确断言判定后，分成两种情况；

pos为第一个节点：       该操作类似 单链表头插入，调用该函数即可；

pos在链表其他位置：先循环next找，与上同理，注意链接的先后顺序；

这里其实还有一种方式，就是将新节点插入到pos位置后，然后将pos的val值和newnode的val值进行交换即可；

// 在pos的前面插入
void SLTInsert(SLNode** pphead, SLNode* pos, SLNDatatype x)
{
	assert(pos);
	assert(pphead);
	assert(*pphead);
	SLNode* cur = *pphead;
	SLNode* newnode = CreateNode(x);

	//pos在头节点
	if (pos == cur)
	{
		SListPushFront(pphead, x);
	}

	while (cur)
	{
		if (cur->next == pos)	//找到pos位置 前
		{
			newnode->next = pos;
			cur->next = newnode;
			return;
		}
		else
		{
			cur = cur->next;

		}
	}

}

 

2.11删除目标位置

与上同理分两种情况：

pos为第一个节点：类似头删除；

pos在其他位置：记录覆盖即可

// 删除pos位置
void SLTErase(SLNode** pphead, SLNode* pos)
{
	assert(pos);
	assert(pphead);
	assert(*pphead);

	//
	SLNode* cur = *pphead;


//while (cur)
//{
//	if (pos == cur)
//	{
//		cur = cur->next;
//		free(pos);
//		pos = NULL;
//		return;
//	}
//	if (cur->next == pos)
//	{
//		cur->next = cur->next->next;
//		free(pos);
//		pos = NULL;
//		return;
//	}
//	else
//	{
//		cur = cur->next;
//	}
//}

	if (pos == *pphead)
	{
		//头删
		SListPopFront(pphead);
	}
	else
	{
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		cur->next = cur->next->next;
		free(pos);
		pos = NULL;
		}	
}

 

2.12单链表销毁

因为链表是动态开辟空间，在最后需要释放置NULL；

void SLTDestroy(SLNode** pphead)
{
	assert(pphead);
	SLNode* cur = *pphead;
	while (cur)
	{
		SLNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

总代码

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"



void test1()
{
	SLNode* s = NULL;
	SListPushBack(&s, 1);
	SListPushBack(&s, 2);
	SListPushBack(&s, 3);
	SListPrint(&s);

	SListPushFront(&s, 5);
	SListPrint(&s);
}

void test2()
{
	SLNode* s = NULL;
	SListPushBack(&s, 1);
	SListPushBack(&s, 2);
	SListPushBack(&s, 3);
	SListPrint(&s);

	SListPopBack(&s);
	SListPrint(&s);

	SListPopFront(&s);
	SListPrint(&s);

	SListPopFront(&s);
	SListPrint(&s);
}

void test3()
{
	SLNode* s = NULL;
	SListPushBack(&s, 1);
	SListPushBack(&s, 2);
	SListPushBack(&s, 3);
	SListPrint(&s);

	SLNode* pos = SListFind(s, 1);
	SListInsertAfter(pos, 4);
	SListPrint(&s);
}

void test4()
{
	SLNode* s = NULL;
	SListPushBack(&s, 1);
	SListPushBack(&s, 2);
	SListPushBack(&s, 3);
	SListPushBack(&s, 4);
	SListPushBack(&s, 5);

	SListPrint(&s);

	SLNode* pos = SListFind(s, 2);
	SListEraseAfter(pos);
	SListPrint(&s);

}

void test5()
{
	SLNode* s = NULL;
	SListPushBack(&s, 1);
	SListPushBack(&s, 2);
	SListPushBack(&s, 3);
	SListPrint(&s);
	SLNode* pos = SListFind(s, 2);
	SLTInsert(&s,pos,6);
	SListPrint(&s);

	SLTErase(&s,pos);
	SListPrint(&s);

}
int main()
{
	//test1();
	//test2();
	//test3();
	//test4();
	test5();

	return 0;
}

SList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

//申请一个节点
SLNode* CreateNode(SLNDatatype x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->val = x;
	newnode->next = NULL;
	return newnode;
}

// 单链表尾插
void SListPushBack(SLNode** pplist, SLNDatatype x)
{
	assert(pplist);
	SLNode* newnode = CreateNode(x);

	if (*pplist == NULL)
	{
		*pplist = newnode;
	}
	else
	{
		//找尾
		SLNode* tail = *pplist;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

//打印单链表
void SListPrint(SLNode** pplist)
{
	assert(pplist);
	SLNode* cur = *pplist;
	//遍历打印
	while (cur)
	{
		printf("%d->", cur->val);
		cur = cur->next;
	}
	printf("NULL\n");
}

// 单链表的头插
void SListPushFront(SLNode** pplist, SLNDatatype x)
{
	assert(pplist);
	SLNode* phead = *pplist;
	SLNode* newnode = CreateNode(x);

	newnode->next = *pplist;
	*pplist = newnode;
}

// 单链表的尾删
void SListPopBack(SLNode** pplist)
{
	assert(pplist);
	assert(*pplist);
	SLNode* cur = *pplist;

	//1.一个节点
	if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	//2.一个以上的节点
	else
	{
		// 找尾
		/*SLNode* prev = NULL;
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}

		free(tail);
		tail = NULL;

		prev->next = NULL;*/
		while (cur->next->next != NULL)
		{
			cur = cur->next;
		}
		free(cur->next);
		cur->next = NULL;
	}
}

// 单链表头删
void SListPopFront(SLNode** pplist)
{
	assert(pplist);
	assert(*pplist);
	
	SLNode* cur = *pplist;
	*pplist = (*pplist)->next;
	free(cur);
	cur = NULL;
}

// 单链表查找
SLNode* SListFind(SLNode* plist, SLNDatatype x)
{
	assert(plist);

	SLNode* cur = plist;
	while (cur)	//遍历查找
	{	
		if (cur->val == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

// 单链表在pos位置之后插入x
void SListInsertAfter(SLNode* pos, SLNDatatype x)
{
	assert(pos);
	SLNode* newnode = CreateNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

// 单链表删除pos位置之后的值
void SListEraseAfter(SLNode* pos)
{
	assert(pos);
	pos位置后还有两个及以上值
	//if (pos->next->next != NULL)
	//{
	//	SLNode* cur = pos->next;	//cur是要删除的位置
	//	SLNode * next = pos->next->next;	//pos链接下一个位置
	//	
	//	pos->next = next;
	//	free(cur);
	//	cur = NULL;
	//}
	pos位置后只有一个或者没有值
	//else
	//{
	//	free(pos->next);
	//	pos->next = NULL;
	//}

	SLNode* cur = pos->next;
	pos->next = pos->next->next;
	free(cur);
	cur = NULL;

}

// 在pos的前面插入
void SLTInsert(SLNode** pphead, SLNode* pos, SLNDatatype x)
{
	assert(pos);
	assert(pphead);
	assert(*pphead);
	SLNode* cur = *pphead;
	SLNode* newnode = CreateNode(x);

	//pos在头节点
	if (pos == cur)
	{
		SListPushFront(pphead, x);
	}

	while (cur)
	{
		if (cur->next == pos)	//找到pos位置 前
		{
			SLNode* prev = cur;
			newnode->next = pos;
			cur->next = newnode;
			return;
		}
		else
		{
			cur = cur->next;

		}
	}

}

// 删除pos位置
void SLTErase(SLNode** pphead, SLNode* pos)
{
	assert(pos);
	assert(pphead);
	assert(*pphead);

	//
	SLNode* cur = *pphead;


//while (cur)
//{
//	if (pos == cur)
//	{
//		cur = cur->next;
//		free(pos);
//		pos = NULL;
//		return;
//	}
//	if (cur->next == pos)
//	{
//		cur->next = cur->next->next;
//		free(pos);
//		pos = NULL;
//		return;
//	}
//	else
//	{
//		cur = cur->next;
//	}
//}

	if (pos == *pphead)
	{
		//头删
		SListPopFront(pphead);
	}
	else
	{
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		cur->next = cur->next->next;
		free(pos);
		pos = NULL;
		}	
}

void SLTDestroy(SLNode** pphead)
{
	assert(pphead);
	SLNode* cur = *pphead;
	while (cur)
	{
		SLNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

SList.h 

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

typedef int SLNDatatype;

typedef struct SListNode        //链表定义
{
	struct SListNode* next;
	SLNDatatype val;

}SLNode;


// 动态申请一个节点
SLNode* CreateNode(SLNDatatype x);

// 单链表尾插
void SListPushBack(SLNode** pplist, SLNDatatype x);

//打印单链表
void SListPrint(SLNode** phead);

// 单链表的头插
void SListPushFront(SLNode** pplist, SLNDatatype x);

// 单链表的尾删
void SListPopBack(SLNode** pplist);

// 单链表头删
void SListPopFront(SLNode** pplist);

// 单链表查找
SLNode* SListFind(SLNode* plist, SLNDatatype x);

// 单链表在pos位置之后插入x
void SListInsertAfter(SLNode* pos, SLNDatatype x);

// 单链表删除pos位置之后的值
void SListEraseAfter(SLNode* pos);

// 在pos的前面插入
void SLTInsert(SLNode** pphead, SLNode* pos, SLNDatatype x);

// 删除pos位置
void SLTErase(SLNode** pphead, SLNode* pos);

//销毁单链表
void SLTDestroy(SLNode** pphead);

以上就是我对单链表的理解和功能实现介绍，身为初学者，作者能力有限，文中不对的地方，需要改进的地方，还望各位指点，感激不尽！！！ 

 

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

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

相关文章

三国杀中的概率学问题4——曹冲

三国杀中的概率学问题4——曹冲

前言 这篇文章是围绕曹冲的称象技能展开的一些数学上的讨论&#xff0c;将涉及到积分、概率论等知识&#xff0c;并会做很多拓展。 值得说明的是&#xff0c;本文受到了这篇文章的一些启发。 连续情形1 先来看一个连续情形的问题。 问题一&#xff1a;假设每张牌的点数是0~1…
阅读更多...
JVM：卡表元素如何维护？（写屏障）

JVM：卡表元素如何维护？（写屏障）

写屏障 上面使用记忆集解决了缩减GC Roots扫描范围的问题&#xff0c;现在又抛出来一个新的问题&#xff0c;卡表元素如何维护的呢&#xff1f;&#xff0c;例如它们何时变脏、谁来把它们变脏等。 何时变脏这个问题应该很明确的&#xff0c;原则上应该发生在引用类型字段赋值…
阅读更多...
编译原理-语法分析-自上而下分析

编译原理-语法分析-自上而下分析

文章目录 语法分析器的功能自上而下分析面临的问题LL&#xff08;1&#xff09;分析法左递归的消除直接左递归非直接左递归 消除左递归的算法消除回溯、提左因子FIRST提左因子FOLLOW集 LL(1)的分析条件LL(1)文法构造FIRST和FOLLOW集合构造每个文法符号的FIRST集合构造FOLLOW集合…
阅读更多...
java网络编程之UDP协议

java网络编程之UDP协议

文章目录 UDP简介一发一收客户端&#xff1a;服务端&#xff1a; 多发多收实现多开客户端&#xff1a;服务端 UDP简介 UDP&#xff08;User Datagram Protocol&#xff09; DatagramSocket 用于创建客户端、服务端DatagramSocket() :创建客户端的Socket对象&#xff0c;系统随…
阅读更多...
C++ 11 新特性

C++ 11 新特性

目录 1. 支持特性的编译器版本2. 模板表达式中空格3. 空指针4. auto5. 统一初始化6. explict7. 范围for8. default&#xff0c;delete9. 化名模板&#xff08;alias template&#xff09;10. using11. noexcept12. override13. final14. decltype15. lambda16. Variadic Templa…
阅读更多...
4.2每日一题（求多元函数在某一点的微分）

4.2每日一题（求多元函数在某一点的微分）

1、分别求x和y的偏导&#xff0c;再相加即可 2、因为多元函数的表达式不方便求偏导&#xff0c;所以可以使用先代后求法&#xff1a; &#xff08;1&#xff09;对x偏导&#xff1a;把y0代入&#xff0c;很容易求出对x偏导的结果 &#xff08;2&#xff09;对y偏导&#xff1a…
阅读更多...
ARM 寄存器

ARM 寄存器

阅读更多...
Django——路由层

Django——路由层

一. 路由匹配 1. 路由匹配注意事项 urlpatterns [url(r^admin/, admin.site.urls),# 首页url(r^$,views.home),# 路由匹配url(r^test/$,views.test),url(r^testadd/$,views.testadd),# 尾页(了解): 后期使用异常捕获处理, 这样的尾页让django的第二次在路径中斜杠APPEND_SL…
阅读更多...
Redis解决缓存问题

Redis解决缓存问题

目录 一、引言二、缓存三、Redis缓存四、缓存一致性1.缓存更新策略2.主动更新 五、缓存穿透六、缓存雪崩七、缓存击穿1.基于互斥锁解决具体业务2.基于逻辑过期解决具体业务 一、引言 在一些大型的网站中会有十分庞大的用户访问流量&#xff0c;而过多的用户访问对我们的MySQL数…
阅读更多...
Linux SSH免密登录

Linux SSH免密登录

目录 简介 创建Linux用户和用户组 配置LINUX静态IP 编辑IP映射 SSH免密登录配置 登录测试 简介 SSH&#xff08;Secure shell&#xff09;是可以在应用程序中提供安全通信的一个协议&#xff0c;通过SSH可以安全地进行网络数据传输&#xff0c;它的主要原理是利用非对称加密…
阅读更多...
Libhybris之线程局部存储TLS实例(五)

Libhybris之线程局部存储TLS实例(五)

简介&#xff1a; CSDN博客专家&#xff0c;专注Android/Linux系统&#xff0c;分享多mic语音方案、音视频、编解码等技术&#xff0c;与大家一起成长&#xff01; 优质专栏&#xff1a;Audio工程师进阶系列【原创干货持续更新中……】&#x1f680; 人生格言&#xff1a; 人生…
阅读更多...
二十三、W5100S/W5500+RP2040树莓派Pico＜Web I/O 通过网页控制板载LED灯＞

二十三、W5100S/W5500+RP2040树莓派Pico＜Web I/O 通过网页控制板载LED灯＞

文章目录 1 前言2 简介2 .1 什么是Web&#xff1f;2.2 Web的优点2.3 Web数据交互原理2.4 Web应用场景 3 WIZnet以太网芯片4 HTTP网络设置示例概述以及使用4.1 流程图4.2 准备工作核心4.3 连接方式4.4 主要代码概述4.5 结果演示 5 注意事项6 相关链接 1 前言 Web只是一个静态的文…
阅读更多...
电源基础元件

电源基础元件

文章目录 电源基础元件理想电压源理想电流源受控电源 电源基础元件 理想电压源 定义 其两端电压总能保持定值或一定的时间函数&#xff0c;其值与流过它的电流i无关的元件叫理想电压源 理想电压源的电压、电流关系 1.电源两端电压由电源本身决定&#xff0c;与外电路无关&…
阅读更多...
桶装水订水送水app有哪些功能？

桶装水订水送水app有哪些功能？

桶装水订水送水app是一款专为送水工量身打造的提供送水服务的软件&#xff0c;在这里&#xff0c;送水人员将更好的在线发布一些送水信息&#xff0c;在线接单等功能&#xff0c;极大的提高了工作效率&#xff0c;方便了日常生活。 系统的商户端&#xff0c;专为送水工日常送水…
阅读更多...
【链表和顺序表的优缺点】

【链表和顺序表的优缺点】

阅读更多...
【计算机网络】VRRP协议理论和配置

【计算机网络】VRRP协议理论和配置

目录 1、VRRP虚拟路由器冗余协议 1.1、协议作用 1.2、名词解释 1.3、简介 1.4、工作原理 1.5、应用实例 2、 VRRP配置 2.1、配置命令 2.2、拓扑与配置&#xff1a; 1、VRRP虚拟路由器冗余协议 1.1、协议作用 虚拟路由冗余协议(Virtual Router Redundancy Protocol&am…
阅读更多...
2023nacos源码解读第2集——nacos-server的启动

2023nacos源码解读第2集——nacos-server的启动

nacos 是一个典型的server-client中间件&#xff0c;server这里安装最新的nacos-server 2.3.0-BETA版本 1.docker启动nacos-server 镜像详情参考nacos-docker项目的readme &#xff0c;很方便&#xff0c;但是官方提供的nacos-server镜像往往可能滞后&#xff0c;且不便于后续…
阅读更多...
【Java 进阶篇】JQuery DOM操作：舞动网页的属性魔法

【Java 进阶篇】JQuery DOM操作：舞动网页的属性魔法

在前端的舞台上&#xff0c;属性操作是我们与HTML元素进行互动的关键步骤之一。而JQuery&#xff0c;这位前端开发的巫师&#xff0c;通过简洁而强大的语法&#xff0c;为我们提供了便捷的属性操作工具。在这篇博客中&#xff0c;我们将深入研究JQuery DOM操作中的属性操作&…
阅读更多...
C语言--1,5,10人民币若干,现在需要18元,一共有多少种?

C语言--1,5,10人民币若干,现在需要18元,一共有多少种?

今天小编给大家分享一下穷举法的一道典型例题 一.题目描述 1,5,10人民币若干,现在需要18元,一共有多少种? 二.思路分析 总共有18块钱&#xff0c;设1元有x张&#xff0c;5元有y张&#xff0c;10元有z张&#xff0c;则有表达式&#xff1a;x5y10z18&#xff0c;穷举法最重要的…
阅读更多...
Unity中雾效的实现方法二

Unity中雾效的实现方法二

文章目录 前言一、声明雾效所需要的内置变体二、在 v2f 中声明顶点传入片段中的雾效插值器三、 在顶点着色器中计算雾效采样四、在片元着色器中进行雾效颜色混合在这里插入图片描述 五、最终效果 前言 Unity中雾效的实现方法二&#xff0c;使用 Unity 自带的方法实现&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023