无头单链表，有完整测试程序

🍟无头单链表

👻无头单链表的所有结点都存储有效信息
👻无头单链表相对带头单链表，在有些涉及更改头节点的函数上需要传二级指针

🍟头文件list.h

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLTDataType;
typedef struct SLTNode {
	SLTDataType data;
	struct SLTNode* next;
}SLTNode;

void SLTPrint(SLTNode* phead);
SLTNode* BuySLTNode(SLTDataType x);
void Destroy_Method1(SLTNode** pphead);
void Destroy_Method2(SLTNode** pphead);

//查
SLTNode* FindBySerialNumber(SLTNode* phead, int n);
SLTNode* FindByContent(SLTNode* phead, SLTDataType x);
//改
void ModefyNodeBySerialNumber(SLTNode* phead, int n, SLTDataType x);
void ModifyNodeByContent(SLTNode* phead, SLTDataType x1, SLTDataType x2);
//增
void PushFront(SLTNode** pphead, SLTDataType x);
void PushBack(SLTNode** pphead, SLTDataType x);

void InsertFrontBySerialNumber(SLTNode** pphead, int n, SLTDataType x);
void InsertFrontByAddress(SLTNode** pphead, SLTNode* pos, SLTDataType x);
void InsertFrontByContent(SLTNode** pphead, SLTDataType x1, SLTDataType x2);

void InsertBackBySerialNumber(SLTNode** pphead, int n, SLTDataType x);
void InsertBackByAddress(SLTNode* pos, SLTDataType x);
void InsertBackByContent(SLTNode* pphead, SLTDataType x1, SLTDataType x2);
//删
void PopFront(SLTNode** pphead);
void PopBack(SLTNode** pphead);

void DeleteFrontNode(SLTNode** pphead, SLTNode* pos);
void DeleteNode(SLTNode** pphead, SLTNode* pos);
void DeleteAfterNode(SLTNode* pos);

//测试
SLTNode* testPush_Front_Back();
void testInsertFront();
void testInsertBack();
void testPop();

🍟函数实现list.c

🥤 辅助操作函数

🍕打印链表函数

//辅助操作（打印链表，动态申请节点）
//打印链表
void SLTPrint(SLTNode* phead) {
	SLTNode* cur = phead;
	while (cur) {//当指针不为空时进入循环
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

🥤 创建节点，销毁链表函数

🍕创建节点函数

//2.动态申请一个节点
SLTNode* BuySLTNode(SLTDataType x) {
	//1.用malloc动态申请一个结点的空间
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	//2.判断是否申请成功，申请失败直接退出程序
	if (newnode == NULL) {
		perror("mallocfail");
		exit(-1);
	}
	//3.给结点的数据域赋值为x，给指针域赋值为NULL
	newnode->data = x;
	newnode->next = NULL;
	//4.返回节点的地址
	return newnode;
}

🍕销毁链表函数

🥓法1：先保留头节点，把后面的删完，最后删头结点

//销毁链表
//法1：先保留头节点，把后面的删完，最后删头结点
void Destroy_Method1(SLTNode** pphead) {
	//链表为空，无需删除
	assert(pphead);
	//先删后面，最后删头
	while ((*pphead)->next) {
		SLTNode* next = (*pphead)->next;
		(*pphead)->next = next->next;
		free(next);
	}
	free(*pphead);
}

🥓法2：从头往后删，头节点的值一直更新

//法2：从头往后删，头节点的值一直更新
void Destroy_Method2(SLTNode** pphead) {
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur) {
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

🥤增删查改——查

🍕1.根据序号查找节点

序号：serial number

// 3.1根据序号查找节点
SLTNode* FindBySerialNumber(SLTNode* phead, int n) {
	SLTNode* cur = phead;
	for (int i = 1;i < n;i++) {
		cur = cur->next;
		//如果被查找结点不存在（超过链表范围），返回空指针
		if (cur == NULL) {
			return NULL;
		}
	}
	return cur;
}

🍕2.根据内容查找结点

//3.2根据内容查找结点
SLTNode* FindByContent(SLTNode* phead, SLTDataType x) {
	SLTNode* cur = phead;
	while (cur) {
		if (cur->data == x) {
			return cur;
		}
		cur = cur->next;
	}
	//查找不到返回空指针
	return NULL;
}

🥤增删查改——改

🍕1.改变节点内数据(通过序号找到被改节点）

//4.1改变节点内数据(通过序号找到被改节点） 
void ModefyNodeBySerialNumber(SLTNode* phead, int n, SLTDataType x) {
	SLTNode* cur = FindBySerialNumber(phead, n);
	cur->data = x;
}

🍕2.改变节点内数据(通过内容找到被改节点）

//4.2改变节点内数据(通过内容找到被改节点）
void ModifyNodeByContent(SLTNode* phead, SLTDataType x1, SLTDataType x2) {
	SLTNode* cur = FindByContent(phead, x1);
	cur->data = x2;
}

🥤增删查改——增

（头插，尾插，在指定节点前插，在指定节点后插）

🍕1.头插

//5.1头插
void PushFront(SLTNode** pphead, SLTDataType x) {
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

👻问：为什么数据x传参时不传指针，而头结点要传二级指针?
👻因为数据x传进来就立马通过BuySLTNode函数被放到在堆区上申请的空间中了，就算不传指针出函数作用域也不会被销毁；而头结点要从原来的链表首结点变成新结点newnode，相当于头结点pphead的值发生变化了，头结点是一个一级指针，对一级指针的修改需要二级指针

🍕2.尾插

//5.2尾插
void PushBack(SLTNode** pphead, SLTDataType x) {
	SLTNode* newnode = BuySLTNode(x);
	if (*pphead == NULL) {
		*pphead = newnode;
		//改变结构体指针，要用二级指针，一级指针只能改形参，出作用域后形参被销毁
	}
	else {
		SLTNode* tail = *pphead;
		while (tail->next != NULL) {
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

🍕3.在指定结点前插入

在指定结点前插入，需要得到指定位置的前置节点。有控制循环法和前置指针法让指针停留至前置节点处，但控制循环法只能在已知插入第几个节点时用，而前置指针法可以在任何情况下用

🥓3.1通过序号指定节点

👻用到了控制for循环法

//5.3在指定结点前插入（通过序号指定节点） 
void InsertFrontBySerialNumber(SLTNode** pphead, int n, SLTDataType x) {
	//产生新结点并赋值
	SLTNode* newnode = BuySLTNode(x);
	SLTNode* ptmp = *pphead;
	//如果要在第一个结点前插入结点，就成了头插
	if (n == 1) {
		PushFront(pphead, x);
		return;
	}
	//将结点放入指定位置的前一个结点，指定位置不包括第一个结点
	for (int i = 2;i < n;i++) {
		ptmp = ptmp->next;
		if (ptmp == NULL)
			printf("位置不合法");
	}
	newnode->next = ptmp->next;
	ptmp->next = newnode;

}

这个函数之所以要传二级指针是因为有头插的情况，需要调用SLTPushFront函数，但其实用一级指针，调用PushFront函数时再取一级指针的地址也行

🥓3.2内容->地址->找到结点

👻用到了while循环加前置指针法

//5.4在指定结点前插入（内容->地址->找到结点） 
//参数二pos是由test.c调用的Find函数返回的节点位置
void InsertFrontByAddress(SLTNode** pphead, SLTNode* pos, SLTDataType x) {
	assert(pphead);
	assert(pos);
	//头插情况
	if (*pphead == pos) {
		PushFront(pphead, x);
	}
	//非头插
	else {
		SLTNode* prev = *pphead;
		while (prev->next != pos) {
			prev = prev->next;
		}
		SLTNode* newnode = BuySLTNode(x);
		newnode->next = pos;
		prev->next = newnode;
		//由于有两个指针分别控制被插入结点和前一个结点，因此这两句顺序随意
	}
}

🥓3.3通过内容指定节点

👻用到了while循环加前置指针法

//5.5在指定结点前插入（通过内容指定节点）

void InsertFrontByContent(SLTNode** pphead, SLTDataType x1, SLTDataType x2) {
	SLTNode* cur = *pphead;
	//头插情况
	if (cur->data == x1) {
		PushFront(pphead, x2);
	}
	//非头插情况
	else {
		cur = FindByContent(*pphead, x1);
		SLTNode* prev = *pphead;
		while (prev->next != cur) {
			prev = prev->next;
		}//此时必须要第二个指针prev
		SLTNode* newnode = BuySLTNode(x2);
		newnode->next = cur;
		prev->next = newnode;
	}
}

当不借助FindByContent函数，只知道指定节点的内容时，需要进入每一个节点对比数据是否一致，这时只能用while训话加前置指针法，因为提前不知道指定位置，无法用通过控制for循环找到指定位置的前置节点

🍕4.在指定结点后插入

🥓4.1通过序号指定节点

//5.6 在指定结点后插入（通过序号指定节点）
void InsertBackBySerialNumber(SLTNode** pphead, int n, SLTDataType x) {
	//原链表为空
	if (*pphead == NULL) {
		SLTNode* newnode = BuySLTNode(x);
		*pphead = newnode;
	}
	//原链表不为空
	SLTNode* newnode = BuySLTNode(x);
	SLTNode* ptmp = *pphead;
	//将结点放入指定位置的后一个结点
	for (int i = 1;i < n;i++) {
		ptmp = ptmp->next;
		//指定节点超过最大长度，报错
		if (ptmp == NULL);
		assert(ptmp);
	}
	newnode->next = ptmp->next;
	ptmp->next = newnode;
}

🥓4.2内容->地址->找到节点

//5.7在指定结点后插入（内容->地址->找到节点）
//参数一pos是由test.c调用的SLTFind函数返回的节点位置
void InsertBackByAddress(SLTNode* pos, SLTDataType x) {
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

🥓4.3通过内容指定节点

不借助FindByContent函数

//5.8在指定结点后插入（通过内容指定节点）不借助FindByContent函数
void InsertBackByContent(SLTNode** pphead, SLTDataType x1, SLTDataType x2) {
	SLTNode* newnode = BuySLTNode(x2);
	SLTNode* cur = *pphead;
	//原链表为空，newnode就是头节点
	if (cur == NULL) {
		*pphead = newnode;
	}
	while (cur) {
		if (cur->data == x1) {
			//指定结点是尾结点
			if (cur->next == NULL) {
				cur->next = newnode;
			}
			//指定结点不是尾结点
			else {
				newnode->next = cur->next;
				cur->next = newnode;
			}
		}
		cur = cur->next;
	}
	//没找到
	return;
}

🥤增删查改——删

（头删，尾删，删除指定位置，删除指定位置的前一个节点，删除指定位置的后一个节点）

🍕1.头删

//6.1头删
void PopFront(SLTNode** pphead) {
	//头结点为空，报错
	assert(*pphead);
	//不为空
	SLTNode* newhead = (*pphead)->next;
	free(*pphead);
	*pphead = newhead;
}

🍕2.尾删

//6.2尾删
void PopBack(SLTNode** pphead) {
	//头结点为空，报错
	assert(*pphead);
	//只有一个结点
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
	}
	//有两个及以上个结点
	else {
		SLTNode* tail = *pphead;
		while (tail->next->next)
		{
			tail = tail->next;//指向尾节点的前置节点
		}
		free(tail->next);
		tail->next = NULL;
	}
}

🍕3.删除指定节点的前一个节点

(由于前置指针法相对于控制for循环法更普适，这里只展示前置指针法）

//删除指定节点的前一个节点
void DeleteFrontNode(SLTNode** pphead, SLTNode* pos) {
	//指定位置不可以是头节点
	if (pos == *pphead) {
		return;
	}
	//指定位置为第二个节点，头结点被删除，更新头结点
	if ((*pphead)->next == pos) {
		PopFront(pphead);
	}
	//定义pos的前置指针prev
	else {
		SLTNode* prevprev = *pphead;
		while (prevprev->next->next != pos) {
			prevprev = prevprev->next;
		}
		free(prevprev->next);
		prevprev->next = pos;
	}
}

🍕4.删除指定位置节点

//删除指定位置节点
void DeleteNode(SLTNode** pphead, SLTNode* pos) {
	//如果删除了头结点，头删函数
	if (pos == *pphead) {
		PopFront(pphead);
	}
	else {
		SLTNode* prev = *pphead;
		while (prev->next != pos) {
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

🍕5.删除指定节点的后一个节点

//删除指定节点的后一个节点
void DeleteAfterNode(SLTNode* pos) {
	//检查pos是否为空
	assert(pos);
	//检查pos是否是尾节点
	assert(pos->next);
	SLTNode* posNext = pos->next;
	pos->next = posNext->next;
	free(posNext);
	posNext = NULL;
}

🍟测试函数test.c

🥤测试头插尾插

SLTNode* testPush_Front_Back() {
	//测试头插PushFront
	printf("请输入头插长度：");
	int n = 0;
	scanf("%d", &n);
	printf("请依次输入结点的值：\n");
	SLTNode* plist = NULL;
	for (int i = 0;i < n;i++) {
		int val = 0;
		scanf("%d", &val);
		PushFront(&plist, val);
	}
	SLTPrint(plist);
	//测试尾插
	printf("请输入尾插长度：");
	int m = 0;
	scanf("%d", &m);
	printf("请依次输入结点的值：\n");
	for (int i = 0;i < m;i++) {
		int val = 0;
		scanf("%d", &val);
		PushBack(&plist, val);
	}
	SLTPrint(plist);
	return plist;
//销毁链表
	Destroy_Method1(&plist);
	//Destroy_Method2(&plist);
}

🥤测试在指定节点前插入

void testInsertFront() {
	SLTNode* plist = testPush_Front_Back();
	//在指定结点前插入（通过序号指定节点）
	printf("在指定结点前插入（通过序号指定节点）\n");
	printf("请输入结点编号：");
	int input1 = 0;
	scanf("%d", &input1);
	printf("请输入插入的数据");
	SLTDataType data1 = 0;
	scanf("%d", &data1);
	InsertFrontBySerialNumber(&plist, input1, data1);
	SLTPrint(plist);

	//在指定结点前插入（内容->地址->找到结点）
	printf("在指定结点前插入（内容->地址->找到结点）\n");
	printf("请输入要插入位置的数据：");
	SLTDataType data2 = 0;
	scanf("%d", &data2);
	SLTNode* pos = FindByContent(plist, data2);
	printf("请输入插入的数据：");
	SLTDataType data3 = 0;
	scanf("%d", &data3);
	InsertFrontByAddress(&plist, pos, data3);
	SLTPrint(plist);

	//在指定结点前插入（通过内容指定节点）
	printf("在指定结点前插入（通过内容指定节点）\n");
	printf("请输入要插入位置的数据：");
	SLTDataType data4 = 0;
	scanf("%d", &data4);
	printf("请输入插入的数据：");
	SLTDataType data5 = 0;
	scanf("%d", &data5);
	InsertFrontByContent(&plist, data4, data5);
	SLTPrint(plist);
	//销毁链表
	Destroy_Method1(&plist);
	//Destroy_Method2(&plist);
}

🥤测试在指定节点后插入

void testInsertBack() {
	SLTNode* plist = testPush_Front_Back();
	//在指定结点后插入（通过序号指定节点）
	printf("在指定结点后插入（通过序号指定节点）\n");
	printf("请输入节点编号：");
	int input2 = 0;
	scanf("%d", &input2);
	printf("请输入插入的数据：");
	SLTDataType data6 = 0;
	scanf("%d", &data6);
	InsertBackBySerialNumber(&plist, input2, data6);
	SLTPrint(plist);

	//在指定结点后插入（内容->地址->找到结点）
	printf("在指定结点后插入（内容->地址->找到结点）\n");
	printf("请输入要插入位置的数据：");
	SLTDataType data7 = 0;
	scanf("%d", &data7);
	SLTNode* pos = FindByContent(plist, data7);
	printf("请输入插入的数据：");
	SLTDataType data8 = 0;
	scanf("%d", &data8);
	InsertBackByAddress(pos, data8);
	SLTPrint(plist);

	//在指定结点后插入（通过内容指定节点）
	printf("在指定结点后插入（通过内容指定节点）\n");
	printf("请输入要插入位置的数据：");
	SLTDataType data9 = 0;
	scanf("%d", &data9);
	printf("请输入插入的数据：");
	SLTDataType data10 = 0;
	scanf("%d", &data10);
	InsertBackByContent(&plist, data9, data10);
	SLTPrint(plist);
	//销毁链表
	Destroy_Method1(&plist);
	//Destroy_Method2(&plist);
}

🥤测试各种删除

void testPop() {
	SLTNode* plist = testPush_Front_Back();
	//测试头删
	printf("测试头删\n");
	PopFront(&plist);
	SLTPrint(plist);

	//测试尾删
	printf("测试尾删\n");
	PopBack(&plist);
	SLTPrint(plist);

	//删除指定节点的前一个节点
	printf("删除指定节点的前一个节点\n");
	printf("请输入指定节点内容：\n");
	SLTDataType data11 = 0;
	scanf("%d", &data11);
	SLTNode* pos1 = FindByContent(plist, data11);
	DeleteFrontNode(&plist, pos1);
	SLTPrint(plist);

	//删除指定位置节点
	printf("删除指定位置节点\n");
	printf("请输入指定节点内容：\n");
	SLTDataType data12 = 0;
	scanf("%d", &data12);
	SLTNode* pos2 = FindByContent(plist, data12);
	DeleteNode(&plist, pos2);
	SLTPrint(plist);

	//删除指定节点的后一个节点
	printf("删除指定节点的后一个节点\n");
	printf("请输入指定节点内容：\n");
	SLTDataType data13 = 0;
	scanf("%d", &data13);
	SLTNode* pos3 = FindByContent(plist, data13);
	DeleteAfterNode(pos3);
	SLTPrint(plist);

	//销毁链表
	Destroy_Method1(&plist);
	//Destroy_Method2(&plist);

}

🥤主函数

测一个的时候其他三个注释掉，要不然会累死的O(∩_∩)O哈哈~😂

int main() {
	testPush_Front_Back();
	testInsertFront();
	testInsertBack();
	testPop();
}

🍟测试结果

🥤测试一：头插尾插

在这里插入图片描述

🥤测试二：在指定节点前插入节点

在这里插入图片描述

🥤测试三：在指定节点后插入节点

在这里插入图片描述

🥤测试四：各种删除

在这里插入图片描述
👻当前是有点小缺陷的，当通过指定内容找到节点时，如果遇到有多个相同数据的情况，会在第一个出现该数据的位置停下进行插入等操作，这是由于当前节点中的数据只是一个简单的数字，当以后节点内数据更多或每个节点都有自己的唯一标识时，就不会有这个缺陷了。

🌈把以上所有代码块连起来就是完整程序啦，最开始是头文件list.h，接下来是函数实现list.c，最后是测试文件test.c，其中分了4个函数。

🌈在插入和删除那块函数有点多，我把想到的全写上了，有点繁琐，大家主要借鉴思路哈🤣😂，如有错误请及时指正，感谢❤️

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

企业内网终端安全无客户端准入控制技术实践

企业内网终端安全无客户端准入控制技术实践

终端无代理/无客户端准入控制技术因其良好的用户体验而倍受创新企业的青睐。无代理/无客户端准入控制技术&#xff0c;顾名思义&#xff0c;是一种在网络中对终端实施访问控制的方法&#xff0c;无需依赖特定的客户端软件。 不同于银行、医院等传统行业的终端准入控制需求&…
阅读更多...
识别万物扫一扫，遇到不认识的物品扫就完事

识别万物扫一扫，遇到不认识的物品扫就完事

随着科技的不断发展&#xff0c;移动设备已经成为人们日常生活中必不可少的工具。移动设备上的扫一扫功能&#xff0c;可以通过摄像头扫描物品&#xff0c;识别并获取相关信息&#xff0c;为人们的生活带来了很大的便利。本文将探讨识别万物扫一扫的使用及原理。 识别万物的使用…
阅读更多...
概念辨析 | SAR运动补偿和自聚焦技术：深入探索雷达图像

概念辨析 | SAR运动补偿和自聚焦技术：深入探索雷达图像

注1：本文系“概念辨析”系列之一，致力于简洁清晰地解释、对比复杂而专业的概念。本次辨析的概念是：合成孔径雷达(SAR)的运动补偿和自聚焦技术。 SAR运动补偿和自聚焦技术：深入探索雷达图像 Synthetic Aperture Radar (SAR) 1 背景介绍 合成孔径雷达（Synthetic Aperture R…
阅读更多...
iPhone 8透明屏的透明度高吗？

iPhone 8透明屏的透明度高吗？

iPhone 8是苹果公司于2017年推出的一款智能手机&#xff0c;它采用了全新的设计和技术&#xff0c;其中一个亮点就是透明屏。 透明屏是指屏幕具有透明度&#xff0c;可以透过屏幕看到背后的物体。 iPhone 8的透明屏采用了最新的OLED技术&#xff0c;这种技术可以实现更高的对比…
阅读更多...
RunnerGo五种压测模式你会配置吗

RunnerGo五种压测模式你会配置吗

我们在做性能测试时需要根据性能需求配置不同的压测模式如&#xff1a;阶梯模式。使用jmeter时我们需要安装插件来配置测试模式&#xff0c;为了方便用户使用&#xff0c;RunnerGo内嵌了压测模式这一选项&#xff0c;今天给大家介绍一下RunnerGo的几种压测模式和怎么根据性能需…
阅读更多...
shell脚本练习

shell脚本练习

#include <myhead.h> //递归实现输入一个数,输出这个数的每一位 void fun1(int data) {if(data 0) return;fun1(data/10);printf("%d\t",data%10);}//递归实现输入一个数,输出这个数的二进制 void fun2(int data) {if(data 0) return;fun2(data/2);printf(&q…
阅读更多...
Redis7学习笔记01

Redis7学习笔记01

一、redis7实战教程简洁 1、大纲&#xff1a; ①、适合对象&#xff0c;从小白到熟手&#xff0c;一套全包圆 ②、Redis专题-大厂面试题&#xff0c;含100道 ③、Redis专题-真实需求生产真实案例 ④、Redis7新特性 2、小白篇高阶篇&#xff1a; 3、大厂面试题&#xff1a…
阅读更多...
软件供应链的基础:SBOM

软件供应链的基础:SBOM

软件作为一种强大的工具&#xff0c;可以简化复杂的技术概念&#xff0c;但随着软件不可思议的力量而来的是一个相互关联的软件依赖迷宫&#xff0c;这些依赖常常构成软件开发的基础。这些依赖关系并非没有缺陷&#xff0c;正如我们从 Log4Shell 这样的事件中所了解到的那样。当…
阅读更多...
git 常用命令有哪些

git 常用命令有哪些

Git 是我们开发工作中使用频率极高的工具&#xff0c;下面总结下他的基本指令有哪些&#xff0c;顺便温习一下。 前言 一般项目中长存2个分支&#xff1a; 主分支&#xff08;master&#xff09; 和开发分支&#xff08;develp&#xff09; 项目存在三种短期分支 &#xff1a…
阅读更多...
【SQL】-【计算两个varchar类型的timestamp的毫秒差】

【SQL】-【计算两个varchar类型的timestamp的毫秒差】

背景 TRANSTAMP3、TRANSTAMP2在Oracle数据库中的类型为varchar&#xff0c;但实际保存的值是时间戳timestamp类型&#xff0c;现在要计算二者的毫秒差 Oracle或MySQL extract(second from (to_timestamp(TRANSTAMP3,yyyy-mm-dd hh24:mi:ss.ff) - to_timestamp(TRANSTAMP2,yyy…
阅读更多...
数据结构—哈夫曼树及其应用

数据结构—哈夫曼树及其应用

5.6哈夫曼树及其应用 5.6.1哈夫曼树的基本概念 路径&#xff1a;从树中一个结点到另一个结点之间的分支构成这两个结点间的路径。 结点的路径长度&#xff1a;两结点间路径上的分支数。 树的路径长度&#xff1a;从树根到每一个结点的路径长度之和。记作 TL 结点数目相同的…
阅读更多...
安全学习DAY14_JS信息打点

安全学习DAY14_JS信息打点

信息打点——前端JS框架 文章目录 信息打点——前端JS框架小节概述-思维导图JS安全概述什么是JS渗透测试&#xff1f;前后端差异JS安全问题流行的Js框架如何判定JS开发应用&#xff1f; 测试方法&#xff08;JS文件的获取以及分析方法1、手工搜索分析2、半自动Burp分析插件介绍…
阅读更多...
Vue.js表单输入绑定

Vue.js表单输入绑定

对于Vue来说&#xff0c;使用v-bind并不能解决表单域对象双向绑定的需求。所谓双向绑定&#xff0c;就是无论是通过input还是通过Vue对象&#xff0c;都能修改绑定的数据对象的值。Vue提供了v-model进行双向绑定。本章将重点讲解表单域对象的双向绑定方法和技巧。 10.1 实现双…
阅读更多...
C语言每日一题：10.不使用+-*/实现加法+找到所有数组中消失的数。

C语言每日一题：10.不使用+-*/实现加法+找到所有数组中消失的数。

题目一&#xff1a; 题目链接&#xff1a; 思路一&#xff1a; 1.两个数二进制之间进行异或如果不产生进位操作那么两个数的和就是就是两个数进行异或的结果。 举例&#xff1a;5&#xff08;0101&#xff09;2&#xff08;0010&#xff09;进行异或等于&#xff1a;7&#xf…
阅读更多...
Unity 使用SharpZipLib解压时报错

Unity 使用SharpZipLib解压时报错

报错信息&#xff1a; NotSupportedException: Encoding 936 data could not be found. Make sure you have correct international System.Text.Encoding.GetEncoding (System.Int32 codepage) ICSharpCode.SharpZipLib.Zip.ZipConstants.ConvertToString。 出现问题分析&…
阅读更多...
【宝藏系列】Linux 常用磁盘管理命令详解

【宝藏系列】Linux 常用磁盘管理命令详解

【宝藏系列】Linux 常用磁盘管理命令详解 文章目录 【宝藏系列】Linux 常用磁盘管理命令详解前言1️⃣ df2️⃣du3️⃣fdisk&#x1f4df;磁盘格式化&#x1f4e0;磁盘检验⌨️磁盘挂载与卸除&#x1f4c0;卸载/dev/hdc6 前言 Linux磁盘管理常用三个命令为df、du和fdisk。 df…
阅读更多...
无涯教程-Lua - 文件I/O

无涯教程-Lua - 文件I/O

I/O库用于在Lua中读取和处理文件。 Lua中有两种文件操作&#xff0c;即隐式(Implicit)和显式(Explicit)操作。 对于以下示例&#xff0c;无涯教程将使用例文件test.lua&#xff0c;如下所示。 -- sample test.lua -- sample2 test.lua 一个简单的文件打开操作使用以下语句。…
阅读更多...
Day11-Webpack前端工程化开发

Day11-Webpack前端工程化开发

Webpack 一 webpack基本概念 遇到问题 开发中希望将文件分开来编写，比如CSS代码，可以分为头部尾部内容，公共的样式。 JS代码也希望拆分为多个文件，分别引入，以后代码比较好维护。 本地图片，希望可以实现小图片不用访问后端，保存在前端代码中就可以了 运行程序时我…
阅读更多...
mongodb docker 及常用命令

mongodb docker 及常用命令

MongoDB属于非关系型数据库&#xff0c;它是由C编写的分布式文档数据库。内部使用类似于Json的bson二进制格式。 中文手册 https://www.w3cschool.cn/mongodb/ 安装 https://www.mongodb.com/try/download/community 二进制安装可见另一篇&#xff1a; centos7 mongodb 4.0.28…
阅读更多...
RabbitMQ 教程 | 第8章 跨越集群的界限

RabbitMQ 教程 | 第8章 跨越集群的界限

&#x1f468;&#x1f3fb;‍&#x1f4bb; 热爱摄影的程序员 &#x1f468;&#x1f3fb;‍&#x1f3a8; 喜欢编码的设计师 &#x1f9d5;&#x1f3fb; 擅长设计的剪辑师 &#x1f9d1;&#x1f3fb;‍&#x1f3eb; 一位高冷无情的编码爱好者 大家好&#xff0c;我是 DevO…
阅读更多...
最新文章

Copyright @ 2022~2023