学习笔记---更进一步的双向链表专题~~

news2024/9/22 19:24:26

目录

1. 双向链表的结构🦊

2. 实现双向链表🐝

2.1 要实现的目标🎯

2.2 创建+初始化🦋

2.2.1 List.h

2.2.2 List.c

2.2.3 test.c

2.2.4 代码测试运行

2.3 尾插+打印+头插🪼

思路分析

2.3.1 List.h

2.3.2 List.c

2.3.3 test.c

2.3.4 代码测试运行

2.4 尾删+头删🐊

2.4.0 思路分析

2.4.1 List.h

2.4.2 List.c

2.4.3 test.c

2.4.4 代码测试运行

2.5 查找数据+pos节点后插入+删除pos节点🦩

2.5.0 思路分析

2.5.1 List.h

2.5.2 List.c

2.5.3 test.c

2.5.4 代码测试运行

2.6 销毁☄️

2.6.0思路分析

1. 一级指针

2.6.1 List.h

2.6.2 List.c

2.6.3 test.c

2.6.4 代码测试运行

2. 二级指针

2.6.1 List.h

2.6.2 List.c

2.6.3 test.c

2.6.4 代码测试运行

2.7 完整代码💦

2.7.1 List.h

2.7.2 List.c

2.7.3 test.c

3. 顺序表和双向链表的分析🍻

1. 双向链表的结构🦊

这里的双向链表，准确的说是：带头双向循环链表

这里的“头节点”指的是“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这⾥“放哨

的”。

“哨兵位”存在的意义：遍历循环链表避免死循环。

注意⚠️

双向链表的每一个节点存储一个有效数据+下一个节点的地址+上一个节点的地址

头节点和尾节点有些特殊：头节点指向的上一个节点的地址是尾节点，尾节点指向的下一个节点的地址是头节点

2. 实现双向链表🐝

2.1 要实现的目标🎯

我们需要多个接口帮助我们实现：创建、一系列具体操作、销毁

具体操作包括：头部/尾部插入数据、头部/尾部删除数据、打印出双向链表、指定节点之后插入数据、删除指定节点的数据、查找指定节点

2.2 创建+初始化🦋

2.2.1 List.h

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

typedef int LTDataType;
//创建双向链表的结构体
typedef struct ListNode {
	LTDataType data;
	struct ListNode* prev;
	struct ListNode* next;
}ListNode;

//初始化
ListNode* LTInit();//不用传入参数，直接调用接口返回一个头节点

2.2.2 List.c

#include"List.h"
//初始化
ListNode* LTInit()//不用传入参数，直接调用接口返回一个头节点
{
	//为头节点申请空间
	ListNode* phead = (ListNode*)malloc(sizeof(ListNode));
	//判断开辟是否成功
	if (phead == NULL)
	{
		perror("malloc error!\n");
		return;
	}
	//开辟成功--->初始化头节点
	phead->data = -1;//头节点不存储有效数据，可以任意赋值
	//只有哨兵位的时候，要实现双向链表，不能指向NULL，否则无法双向循环，所以我们指向自己
	phead->prev = phead->next = phead;
	return phead;
}

2.2.3 test.c

#include"List.h"
void ListTest()
{
	ListNode* plist = LTInit();
}
int main()
{
	ListTest();
	return 0;
}

2.2.4 代码测试运行

2.3 尾插+打印+头插🪼

思路分析

2.3.1 List.h

//在双向链表中不会改变哨兵位，所以这里都可以传一级指针
//尾插
void LTPushBack(ListNode* phead, LTDataType x);

//打印
void LTPrint(ListNode* phead);

//头插
void LTPushFront(ListNode* phead, LTDataType x);

2.3.2 List.c

//在双向链表中不会改变哨兵位，所以这里都可以传一级指针
// 只改变数据，不改变地址

//开辟空间
ListNode* ListBuyNode(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (node == NULL)
	{
		perror("malloc error!\n");
		return;
	}
	node->data = x;
	node->next = node->prev = NULL;
	return node;
}

//尾插
void LTPushBack(ListNode* phead, LTDataType x)
{
	assert(phead);//注意哨兵位不能为空
	//申请空间
	ListNode* node = ListBuyNode(x);
	//先处理node的前驱指针和后继指针
	node->prev = phead->prev;
	node->next = phead;
	//再处理之前的尾节点和phead
	phead->prev->next = node;
	phead->prev = node;
}

//打印
void LTPrint(ListNode* phead)
{
	//哨兵位不能改变
	ListNode* cur = phead->next;
	while (cur != phead)//当cur再次指向phead的时候，循环结束
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

//头插
void LTPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);//注意哨兵位不能为空
	//申请空间
	ListNode* node = ListBuyNode(x);
	//node插入头节点之后才算头插
	//先处理node的前驱指针和后继指针
	node->prev = phead;
	node->next = phead->next;
	//再处理phead和phead->next
	phead->next->prev = node;
	phead->next = node;
}

2.3.3 test.c

#include"List.h"
void ListTest()
{
	ListNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);//1 2 3 4 
	LTPushFront(plist, 5);
	LTPrint(plist);//5 1 2 3 4 
}
int main()
{
	ListTest();
	return 0;
}

2.3.4 代码测试运行

2.4 尾删+头删🐊

2.4.0 思路分析

2.4.1 List.h

//尾删
void LTPopBack(ListNode* phead);

//头删
void LTPopFront(ListNode* phead);

2.4.2 List.c

//尾删
void LTPopBack(ListNode* phead)
{
	//不能为空链表，只有一个哨兵位不能尾删
	assert(phead&&(phead->prev!=phead||phead->next!=phead));
	ListNode* del = phead->prev;//phead->prev就是尾节点
	//先处理del
	del->prev->next = phead;
	//再处理phead
	phead->prev = del->prev;
	free(del);
	del = NULL;
}

//头删
void LTPopFront(ListNode* phead)
{
	//不能为空链表，只有一个哨兵位不能头删
	assert(phead && (phead->prev != phead || phead->next != phead));
	ListNode* del = phead->next;
	del->next->prev = phead;
	phead->next = del->next;
	free(del);
	del = NULL;
}

2.4.3 test.c

#include"List.h"
void ListTest()
{
	ListNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);//1 2 3 4 
	LTPushFront(plist, 5);
	LTPrint(plist);//5 1 2 3 4 
	LTPopBack(plist);
	LTPrint(plist);//5 1 2 3
	LTPopFront(plist);
	LTPrint(plist);//1 2 3
}
int main()
{
	ListTest();
	return 0;
}

2.4.4 代码测试运行

2.5 查找数据+pos节点后插入+删除pos节点🦩

2.5.0 思路分析

2.5.1 List.h

//查找数据
ListNode* LTFind(ListNode* phead, LTDataType x);

//pos节点之后插入
void LTPushAfter(ListNode* pos, LTDataType x);

//删除pos节点
void LTErase(ListNode* pos);

2.5.2 List.c

//查找数据
ListNode* LTFind(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur!= phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

//pos节点之后插入
void LTPushAfter(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* node = ListBuyNode(x);
	//node
	node->next = pos->next;
	node->prev = pos;
	//pos
	pos->next = node;
	node->next->prev = node;
}

//删除pos节点
void LTErase(ListNode* pos)
{
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

2.5.3 test.c

#include"List.h"
void ListTest()
{
	ListNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);//1 2 3 4 
	LTPushFront(plist, 5);
	LTPrint(plist);//5 1 2 3 4 
	LTPopBack(plist);
	LTPrint(plist);//5 1 2 3
	LTPopFront(plist);
	LTPrint(plist);//1 2 3
	ListNode* find = LTFind(plist, 1);
	/*LTPushAfter(find, 4);*/	
	//LTPrint(plist);//1 4 2 3
	LTErase(find);
	LTPrint(plist);//2 3

}
int main()
{
	ListTest();
	return 0;
}

2.5.4 代码测试运行

2.6 销毁☄️

2.6.0思路分析

一开始的初始化，我们直接调用了接口，返回头节点进行初始化。我们没有考虑一级指针还是二级指针的问题。

那么，最后的销毁又该怎么办？是一级指针？还是二级指针？下面我们一一来尝试

1. 一级指针

2.6.1 List.h
//销毁
void LTDestroy(ListNode* phead);
2.6.2 List.c
//销毁
void LTDestroy(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	while(cur!=phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	//注意哨兵位还没有释放
	free(phead);
	phead = NULL;
}
2.6.3 test.c
#include"List.h"
void ListTest()
{
	ListNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);//1 2 3 4 
	//LTPushFront(plist, 5);
	//LTPrint(plist);//5 1 2 3 4 
	//LTPopBack(plist);
	//LTPrint(plist);//5 1 2 3
	//LTPopFront(plist);
	//LTPrint(plist);//1 2 3
	//ListNode* find = LTFind(plist, 1);
	/*LTPushAfter(find, 4);*/	
	LTPrint(plist);//1 4 2 3
	//LTErase(find);
	//LTPrint(plist);//2 3
	LTDestroy(plist);

}
int main()
{
	ListTest();
	return 0;
}
2.6.4 代码测试运行

一级指针：
phead的改变不影响plist，phead释放之后，plist指向已经释放掉的空间——>把plist置为空

那么置为空之前，还要不要将plist指向的空间再free一次？

我们尝试一下

那么再思考一下：一级指针是会导致phead的改变不影响plist，那么plist是什么没有改变？是指plist保存的值没有被改变还是plist的这块空间的地址没有被释放？

这里报错指的是plist指向无效地址

注意⚠️
如果plist的地址没有被释放，那么直接free（plist）是不会报错的

所以在一级指针的情况下：plist的地址已经被释放了，没有被置为空的可以理解是plist的地址名称

2.6.5 一级指针的改进---test.c

2. 二级指针

2.6.1 List.h
//销毁
//void LTDestroy(ListNode* phead);
void LTDestroy(ListNode** phead);
2.6.2 List.c
//销毁
void LTDestroy(ListNode** phead)
{
	assert(phead && *phead);
	ListNode* cur = (*phead)->next;
	while (cur != *phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(*phead);
	*phead = NULL;
}
2.6.3 test.c
#include"List.h"
void ListTest()
{
	ListNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);//1 2 3 4 
	//LTPushFront(plist, 5);
	//LTPrint(plist);//5 1 2 3 4 
	//LTPopBack(plist);
	//LTPrint(plist);//5 1 2 3
	//LTPopFront(plist);
	//LTPrint(plist);//1 2 3
	//ListNode* find = LTFind(plist, 1);
	///*LTPushAfter(find, 4);*/	
	LTPrint(plist);//1 4 2 3
	//LTErase(find);
	//LTPrint(plist);//2 3
	//LTDestroy(plist);
	//plist = NULL;
	LTDestroy(&plist);
}
int main()
{
	ListTest();
	return 0;
}
2.6.4 代码测试运行

虽然，二级指针不用手动将plist置为空
但是，更推荐一级指针，因为其他接口基本上都是一级指针——>保持接口的一致性

2.7 完整代码💦

2.7.1 List.h

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

typedef int LTDataType;
//创建双向链表的结构体
typedef struct ListNode {
	LTDataType data;
	struct ListNode* prev;
	struct ListNode* next;
}ListNode;

//初始化
ListNode* LTInit();//不用传入参数，直接调用接口返回一个头节点

//在双向链表中不会改变哨兵位，所以这里都可以传一级指针
//尾插
void LTPushBack(ListNode* phead, LTDataType x);

//打印
void LTPrint(ListNode* phead);

//头插
void LTPushFront(ListNode* phead, LTDataType x);

//尾删
void LTPopBack(ListNode* phead);

//头删
void LTPopFront(ListNode* phead);

//查找数据
ListNode* LTFind(ListNode* phead, LTDataType x);

//pos节点之后插入
void LTPushAfter(ListNode* pos, LTDataType x);

//删除pos节点
void LTErase(ListNode* pos);

//销毁
void LTDestroy(ListNode* phead);

2.7.2 List.c

#include"List.h"
//初始化
ListNode* LTInit()//不用传入参数，直接调用接口返回一个头节点
{
	//为头节点申请空间
	ListNode* phead = (ListNode*)malloc(sizeof(ListNode));
	//判断开辟是否成功
	if (phead == NULL)
	{
		perror("malloc error!\n");
		return;
	}
	//开辟成功--->初始化头节点
	phead->data = -1;//头节点不存储有效数据，可以任意赋值
	//只有哨兵位的时候，要实现双向链表，不能指向NULL，否则无法双向循环，所以我们指向自己
	phead->prev = phead->next = phead;
	return phead;
}

//在双向链表中不会改变哨兵位，所以这里都可以传一级指针
// 只改变数据，不改变地址

//开辟空间
ListNode* ListBuyNode(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (node == NULL)
	{
		perror("malloc error!\n");
		return;
	}
	node->data = x;
	node->next = node->prev = NULL;
	return node;
}

//尾插
void LTPushBack(ListNode* phead, LTDataType x)
{
	assert(phead);//注意哨兵位不能为空
	//申请空间
	ListNode* node = ListBuyNode(x);
	//先处理node的前驱指针和后继指针
	node->prev = phead->prev;
	node->next = phead;
	//再处理之前的尾节点和phead
	phead->prev->next = node;
	phead->prev = node;
}

//打印
void LTPrint(ListNode* phead)
{
	//哨兵位不能改变
	ListNode* cur = phead->next;
	while (cur != phead)//当cur再次指向phead的时候，循环结束
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

//头插
void LTPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);//注意哨兵位不能为空
	//申请空间
	ListNode* node = ListBuyNode(x);
	//node插入头节点之后才算头插
	//先处理node的前驱指针和后继指针
	node->prev = phead;
	node->next = phead->next;
	//再处理phead和phead->next
	phead->next->prev = node;
	phead->next = node;
}

//尾删
void LTPopBack(ListNode* phead)
{
	//不能为空链表，只有一个哨兵位不能尾删
	assert(phead&&(phead->prev!=phead||phead->next!=phead));
	ListNode* del = phead->prev;//phead->prev就是尾节点
	//先处理del
	del->prev->next = phead;
	//再处理phead
	phead->prev = del->prev;
	free(del);
	del = NULL;
}

//头删
void LTPopFront(ListNode* phead)
{
	//不能为空链表，只有一个哨兵位不能头删
	assert(phead && (phead->prev != phead || phead->next != phead));
	ListNode* del = phead->next;
	del->next->prev = phead;
	phead->next = del->next;
	free(del);
	del = NULL;
}

//查找数据
ListNode* LTFind(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

//pos节点之后插入
void LTPushAfter(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* node = ListBuyNode(x);
	//node
	node->next = pos->next;
	node->prev = pos;
	//pos
	pos->next = node;
	node->next->prev = node;
}

//删除pos节点
void LTErase(ListNode* pos)
{
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

//销毁
void LTDestroy(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	while(cur!=phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	//注意哨兵位还没有释放
	free(phead);
	phead = NULL;
}

2.7.3 test.c

#include"List.h"
void ListTest()
{
	ListNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);//1 2 3 4 
	LTPushFront(plist, 5);
	LTPrint(plist);//5 1 2 3 4 
	LTPopBack(plist);
	LTPrint(plist);//5 1 2 3
	LTPopFront(plist);
	LTPrint(plist);//1 2 3
	ListNode* find = LTFind(plist, 1);
	/*LTPushAfter(find, 4);*/	
	//LTPrint(plist);//1 4 2 3
	LTErase(find);
	LTPrint(plist);//2 3
	LTDestroy(plist);
	plist = NULL;
}
int main()
{
	ListTest();
	return 0;
}

3. 顺序表和双向链表的分析🍻

不同点顺序表链表（单链表）
存储空间上物理上一定连续逻辑上连续，但物理上不一定连续
随机访问支持O（1）不支持：O（N）
任意位置插入或者删除元素看你需要搬移元素，效率低O（N）只需要改变指针指向
插入动态顺序表，空间不够的时候需要扩容没有容量的概念
应用场景元素高效存储+频繁访问任意位置插入和删除频繁

本次的分享到这里就结束了！！！

PS：小江目前只是个新手小白。欢迎大家在评论区讨论哦！有问题也可以讨论的！

如果对你有帮助的话，记得点赞👍+收藏⭐️+关注➕

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

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

相关文章

一张图系列 - “kv cache“

一张图系列 - “kv cache“

我觉得回答这个问题需要知道3个知识点&#xff1a; 1、multi-head-attention是如何计算的&#xff1f;attention的数学公式&#xff1f; kv cache是如何存储和传递的&#xff1f; 2、kv cache 的原理步骤是什么&#xff1f;为什么降低了消耗&#xff1f; 3、kv cache 代码模…
阅读更多...
Matlab神经网络工具箱——一个例子搞定神经网络算法

Matlab神经网络工具箱——一个例子搞定神经网络算法

本文用到的数据来自于matlab神经网络 数据的文件提取码以及链接会放在评论区 分析数据 这里大致是整个数据的样子&#xff0c;下面来分析数据&#xff1a; ①整个数据一共有401个输入&#xff0c;这里体现的也就是有401种吸光度 ②前五十组数据&#xff0c;既有输入也有输出&a…
阅读更多...
2023阿里云双十一服务器优惠价格87元/年，你敢信吗？

2023阿里云双十一服务器优惠价格87元/年，你敢信吗？

2023阿里云双十一服务器优惠价格87元/年&#xff0c;你敢信吗&#xff1f;确实是87元一年&#xff0c;轻量应用服务器2核2G3M带宽&#xff0c;不限制月流量&#xff0c;自带50GB系统盘。活动阿里云服务器网&#xff1a;aliyunfuwuqi.com/go/1111 阿里云轻量应用服务器2核2G3M带…
阅读更多...
逆向第一课---安装ADB工具，并使用夜神模拟器连接

逆向第一课---安装ADB工具，并使用夜神模拟器连接

1、安装ADB 如果安装了Android SDK可以直接去android_sdk/platform-tools/目录下使用ADB命令。 如果没有安装Android SDK&#xff0c;需要先通过下面的地址下载ADB https://adbdownload.com/ 根据自己的系统点击下载&#xff0c;我这里使用Windows系统&#xff0c;所以下载Wi…
阅读更多...
电商接口api数据比价接口推荐

电商接口api数据比价接口推荐

当前&#xff0c;受诸多因素的影响&#xff0c;经济下行&#xff0c;在日趋激烈的市场竞争中&#xff0c;很多企业也都面临着越来越大的生存压力&#xff0c;企业的盈利空间也逐渐被压缩。因此&#xff0c;越来越多的企业在控制成本方面更下功夫&#xff0c;这也就对企业采购提…
阅读更多...
SiC器件概念

SiC器件概念

来源&#xff1a;A SiC Trench MOSFET concept offering improved channel mobility and high reliability SiC MOSFET设计挑战 虽然碳化硅的使用由于是一种宽带隙材料而具有许多优点&#xff0c;但与硅也存在一些值得注意的差异&#xff0c;这导致在制造基于4H-SiC多晶型的Si…
阅读更多...
ASO优化之如何提高在本地搜索时的可见度

ASO优化之如何提高在本地搜索时的可见度

应用本地化是让我们的应用安装量、转化率实现增长的最佳策略之一。通过本地化&#xff0c;可以让我们的应用程序匹配更广泛的受众&#xff0c;甚至可以使其对不同国家/地区的用户更具吸引力。 1、如何使用搜索优化进行本地搜索&#xff1f; 本地化实际上是应用搜索优化的一部分…
阅读更多...
公司电脑如何限制安装软件

公司电脑如何限制安装软件

公司电脑如何限制安装软件 安企神终端管理系统下载使用 在企业环境中&#xff0c;电脑已经成为企业中必不可少的办公工具&#xff0c;确保员工的生产力和公司的信息安全是至关重要的。为了实现这一目标&#xff0c;公司可能会限制员工在某些情况下安装软件或者由管理员来为终…
阅读更多...
Linux——文件权限属性和权限管理

Linux——文件权限属性和权限管理

文件权限属性和权限管理 本章思维导图&#xff1a; 注&#xff1a;本章思维导图对应的Xmid文件和.png文件都以传到“资源” 文章目录 文件权限属性和权限管理1. sudo提权和sudoers文件1.1 sudo提权和成为root的区别 2. 权限2.1 Linux群体2.1.1 为什么要有所属组2.1.2 修改文件…
阅读更多...
拥抱AI-ChatGPT:人类新纪元

拥抱AI-ChatGPT:人类新纪元

最近大模型通用智能应用持续发酵&#xff0c;各大科技公司都陆续推出了基于通用大模型的智能应用产品&#xff0c;典型的如OpenAI的ChatGPT、微软的BingChat、百度的文心一言、360的智脑、阿里的通义千问等。当然最火的要属于ChatGPT了&#xff0c;从去年年底推出到现在已经有很…
阅读更多...
模型工具实现数据库批量追加到空的数据库

模型工具实现数据库批量追加到空的数据库

一. 下载&#xff1a; http://dt1.8tupian.net/2/29913a50b1000.pg3二. 介绍&#xff1a;许多时候我们的作业数据库需要批量追加到标准的汇交数据库&#xff0c;手动一个层一个层的追加比较麻烦&#xff0c;本工具实现将空间图层和属性数据自动追加到标准空库。
阅读更多...
【psychopy】【脑与认知科学】认知过程中的面孔识别加工

【psychopy】【脑与认知科学】认知过程中的面孔识别加工

目录 实验描述 实验思路 python实现 实验描述 现有的文献认为&#xff0c;人们对倒置的面孔、模糊的面孔等可能会出现加工时长增加、准确率下降的问题&#xff0c;现请你设计一个相关实验&#xff0c;判断不同的面孔是否会出现上述现象。请按照认知科学要求&#xff0c;画…
阅读更多...
详细介绍如何使用 NeRF 进行 3D 体积渲染-附源码下载

详细介绍如何使用 NeRF 进行 3D 体积渲染-附源码下载

介绍 在此示例中，我们展示了 Ben Mildenhall 等人的研究论文 NeRF：将场景表示为用于视图合成的神经辐射场的最小实现 。等人。作者提出了一种巧妙的方法，通过神经网络对体积场景函数进行建模来合成场景的新颖视图。 为了帮助您直观地理解这一点，让我们从以下问题开始： 是…
阅读更多...
1819_ChibiOS的互斥信号与条件变量

1819_ChibiOS的互斥信号与条件变量

全部学习汇总&#xff1a; GreyZhang/g_ChibiOS: I found a new RTOS called ChibiOS and it seems interesting! (github.com) 1. 关于会吃信号与条件变量的全局配置提供了4个配置信息&#xff0c;分别是互斥信号的使能、互斥信号的递归支持、条件变量的使能、条件变量的超时使…
阅读更多...
jQuery图像查看插件Zoom.js

jQuery图像查看插件Zoom.js

效果图 图片点击放大&#xff0c;再次点击或者滚动窗口或者按 ESC 键即可恢复原始大小&#xff0c;非常流畅&#xff0c;使用方法也非常简单&#xff0c;引入zoom.js和zoom.css文件之后&#xff0c;对图片添加data-action"zoom"属性即可。 使用方法 1&#xff0c;将…
阅读更多...
【网络】详解http协议

【网络】详解http协议

目录 一、认识URLurlencode和urldecode 二、HTTP协议HTTP协议格式HTTP的方法HTTP的状态码HTTP常见Header 一、认识URL URL叫做统一资源定位符&#xff0c;也就是我们平时俗称的网址&#xff0c;是因特网的万维网服务程序上用于指定信息位置的表示方法。 urlencode和urldecode …
阅读更多...
21.10 Python 使用CRC32校验文件

21.10 Python 使用CRC32校验文件

CRC文件校验是一种用于验证文件完整性的方法&#xff0c;通过计算文件的CRC值并与预先计算的CRC校验值进行比较&#xff0c;来判断文件是否发生变化&#xff0c;此类功能可以用于验证一个目录中是否有文件发生变化&#xff0c;如果发生变化则我们可以将变化打印输出&#xff0c…
阅读更多...
初次学习dubbo记录

初次学习dubbo记录

---------------------------------------10.17---------------------------------------- 集群和分布式概念 集群&#xff1a;很多"人"做的相同的一件事&#xff0c;即使有一个人挂掉了&#xff0c;也不会对系统造成致命影响 分布式&#xff1a;很多"人"…
阅读更多...
外卖小程序：技术实现与关键代码

外卖小程序：技术实现与关键代码

在当今数字化的餐饮市场中&#xff0c;外卖小程序扮演着重要的角色。这些应用程序通过技术实现点餐、支付和配送&#xff0c;为用户提供方便快捷的服务。下面我们来深入探讨构建外卖小程序的关键技术要点和代码示例。 1. 前端开发 前端是用户与应用程序交互的接口&#xff0…
阅读更多...
三年轻量：腾讯云3年轻量2核2G4M服务器366上三年时长

三年轻量：腾讯云3年轻量2核2G4M服务器366上三年时长

腾讯云轻量应用服务器三年特价&#xff0c;3年轻量2核2G4M服务器&#xff0c;2023双十一优惠价格366元三年&#xff0c;自带4M公网带宽&#xff0c;下载速度可达512KB/秒&#xff0c;300GB月流量&#xff0c;50GB SSD盘系统盘&#xff0c;阿腾云atengyun.com分享腾讯云轻量2核2…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023