数据结构（ing）

news2025/1/6 2:01:40

学习内容 

指针

指针的定义：

指针是一种变量，它的值为另一个变量的地址，即内存地址。

指针在内存中也是要占据位置的。

指针类型：

指针的值用来存储内存地址，指针的类型表示该地址所指向的数据类型并告诉编译器如何解释该指针所指向的内存中的数据。

指针的初始化：

指针的赋值是运用&这个操作符完成的，用于产生操作数的内存地址。

指针的运用（取值）：

运用单目操作符*来取出指针所指向的内存块的值

	int a = 921; 
	int* b = &a; // b取得a在内存中的起始位置 
	int c = *b; // 得到b指向的内存块的值
	printf("a在内存中的起始地址为 %p \n", (void*)b);
	printf("b指针在内存中所指向的值为 %d \n", c);

 练习：

*&a = 25 

理解：

&a表示取a的起始地址，*（&a）表示取（&a）所指向的内存块的值

所以其实这个意思就是a=25

线性表

概念

定义：

具有相同特性的数据元素的一个有限序列，由n (n >= 0) 个数据元素（结点）a1、a2、a3.....an组成的有限序列。包括起始节点、终端节点、数据元素......

存储结构：

1.顺序存储结构：

        把逻辑上相邻的数据元素存储在物理上相邻的存储单元中的存储结构

2.链式存储结构：

         结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻。访问时只能通过头指针进入链表。

顺序存储结构（顺序表）

优点：以物理位置相邻表示逻辑关系，任一元素均可随机存取，存储密度大。

缺点：在插入、删除某一元素时，需要移动大量元素，浪费存储空间，属于静态存储形式，数据元素的个数不能自由扩充。

特点： 地址连续、依次存放、随机存取 、类型相同

存储表示

逻辑结构：（a1，a2，a3，...... an）

存储结构：

顺序表的定义

顺序表的数组下标是从0开始的

数组静态分配

#define N 100

typedef struct {
	int e;
} Node;

typedef struct {  
	Node element[N]; //静态分配数组
	int length; //存储顺序表的长度
} SqList;

数组动态分配

typedef struct {
	int e;
} Node;

typedef struct {  
	Node *element; //动态分配数组
	int length; //存储顺序表的长度
} SqList;

顺序表的基本操作

初始化线性表

// 线性表的初始化
bool InitList_Sq(SqList &L, int n)
{
	// 分配内存
	L.element = (Node*)malloc(sizeof(Node)*n);	
	if (!L.element) return false; //分配失败
	L.length = 0; // 初始化空表长度为0
	return true; // 初始化成功
}

销毁线性表

// 销毁线性表
void DestroyList(SqList &L)
{
	if (L.element) delete L.element; // 释放存储空间
}

清空线性表

// 清空线性表
void ClearList(SqList &L)
{
	L.length = 0; //将线性表的长度置为0
}

求线性表的长度

// 求线性表的长度
int GetLength(SqList L) 
{
	return L.length;
}

判断线性表是否为空

// 判断线性表是否为空
bool IsEmpty(SqList L)
{
	if (L.length == 0) return true;
	else return false;
}

顺序表取值

// 顺序表的取值（根据位置获取元素）
bool GetElement(int idx, SqList L, Node &e) 
{
	if (idx < 1 || idx > L.length) return false;
	e = L.element[idx - 1];
	return true;
}

按值查找

// 按值查找
int LocateElem(SqList L, Node e) 
{
	for (int i = 0; i < L.length; i ++)
	{
		if (L.element[i].e == e.e) 
				return i + 1;
	}
	return 0; // 查找失败
}

顺序表的插入

// 顺序表的插入
bool ListInsert_Sq(SqList &L, int idx, Node e)
{
	if (idx < 1 || idx > L.length + 1) return false;
	for (int i = L.length - 1; i >= idx - 1; i --)
	{
		L.element[i + 1] = L.element[i];
	}
	L.element[idx - 1] = e;
	L.length ++;
	return true;
}

顺序表的删除

// 顺序表的删除
bool ListDelete_Sq(SqList &L, int idx)
{
	if (idx < 1 || idx > L.length) return false;
	for (int i = idx; i < L.length; i ++)
	{
		L.element[i - 1] = L.element[i];
	}
	L.length --;
	return true;
}

链式存储结构（链表）

定义：

n个结点由指针链组成一个链表。它是线性表的链式存储映像，称为线性表的链式存储结构。

概念表示：

结点：

数据元素的存储映像称为结点，它由数据域和指针域两部分组成。

特殊结点：

  • 头结点：在链表的首元结点之前额外设置的一个结点。
  • 首元结点：链表中存储第一个数据元素a1的结点

数据域：存储当前结点的数据。

指针域：存储下一个节点的位置。 

头指针： 

指向链表中第一个节点的指针。

链表：

 链表分为单链表、双链表、循环链表。

  • 单链表：结点只有一个指针域，存储的是下一个节点的地址。
  • 双链表：结点有两个指针域。存储相邻两个结点的地址。
  • 循环链表：是一种头尾相接的链表，表中的最后一个结点的指针域指向头结点，整个链表形成一个环。

存储表示：

逻辑结构：（a1，a2，a3，...... an）

存储结构：

第一种 (无头结点) ：

第二种（有头结点）:

空表

1.无头结点时，头指针为空时表示空表，表示空表。

2.有头结点时，头结点的指针域为空时，表示空表。

单链表

数组模拟单链表：数组模拟单链表文章浏览阅读118次。数组模拟单链表https://blog.csdn.net/m0_73569492/article/details/128693718?ops_request_misc=%257B%2522request%255Fid%2522%253A%25220bb3388a11ebbfdf7502eedcb53293d6%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=0bb3388a11ebbfdf7502eedcb53293d6&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~rank_v31_ecpm-1-128693718-null-null.nonecase&utm_term=%E5%8D%95%E9%93%BE%E8%A1%A8&spm=1018.2226.3001.4450

链表定义

定义了两种类型：LNode 为结构体类型；LinkList 为指向该结构体类型的指针类

typedef struct {
	int e;
} Data;

typedef struct Lnode {
	Data data; // 结点的数据域
	struct Lnode *next; // 结点的指针域
} LNode, *LinkList; // 定义了两种类型：LNode 为结构体类型；LinkList 为指向该结构体类型的指针类型。

LinkList L; // 定义链表L
LNode *p; // 定义结点指针
LinkList q; //定义结点指针

链表操作
初始化单链表

1.生成新节点作为头结点

2.头指针指向头结点

3.头结点的指针域指向空

分配内存：

L = (LinkList)malloc(sizeof(LNode));

这一行代码调用了 malloc 函数来为一个新的 LNode 结构体分配内存。malloc 返回的是一个指向所分配内存块的指针（类型为 void*），然后通过 (LinkList) 强制转换为 LinkList 类型（即 LNode*）。此时，L 已经指向了这块新分配的内存，这块内存代表了一个新的链表节点。

// 单链表的初始化
bool InitList_L(LinkList &L) 
{
	L = (LinkList)malloc(sizeof(LNode)); 
	L->next = NULL;
	return true;
}
 判断单链表是否为空

其实就是判断头结点的指针域是否为空，如果为空，则代表是空表，如果不为空，则代表不为空表。

// 判断链表是否为空
bool IsEmpty_List(LinkList L)
{
	if (L->next == NULL) 
		return true;
	return false;
}
单链表的销毁

销毁过程如下：

// 单链表的销毁
void Destroy_List(LinkList &L)
{
	LNode *p;
	while (L)
	{
		p = L;
		L = L->next;
		free(p);
	}
}
清空单链表

// 清空单链表
void Clear_List(LinkList &L)
{
	LNode *p;
	while (L->next) 
	{
		p = L->next;
		L->next = p->next;
		free(p);
	}
}
求单链表的表长
// 求单链表的表长
int Caculate_Length(LinkList L)
{
	int cnt = 0;
	for (LNode* p = L->next; p != NULL; p = p->next)
		cnt ++;
		
	return cnt;
}
根据位置获取元素
// 取值-取单链表中第idx个元素的内容
bool GetElement(LinkList L, Data &e, int idx)
{
	int cnt = 0;
	for (LNode* p = L->next; p != NULL; p = p->next)
	{
		 cnt ++;
		 if (cnt == idx) 
		 {
		 	e = p->data;
		 	return true;
		 }	
	}
	return false;
}
按值查找
// 按值查找-根据数据获取该数据所在位置
int GetIdx(LinkList L, Data &element)
{
	int cnt = 0;
	for (LNode* p = L->next; p != NULL; p = p->next)
	{
		 cnt ++;
		 if (p->data.e == element.e) return cnt; 
	}
	return -1;
}
单链表的插入（任意位置）

// 单链表的插入-在第i个元素之前插入
bool Insert(LinkList &L, int idx, Data element)
{
	int cnt = 0;
	for (LNode* p = L; p->next != NULL; p = p->next)
	{
		 if (cnt == idx - 1)
		 {
		 	LNode *e = (LNode*)malloc(sizeof(LNode));
		 	e->data = element;
		 	e->next = p->next;
		 	p->next = e;
		 	return true;
		 }
		 cnt ++;
	}	
	return false;
}
单链表删除元素

// 删除-删除第idx个元素
bool Delete(LinkList &L, int idx)
{
	int cnt = 0;
	for (LNode* p = L; p != NULL; p = p->next)
	{
		 if (cnt == idx - 1)
		 {
		 	LNode *q = p->next;
		 	p->next = q->next;
		 	free(q);
		 	return true;
		 }
		 cnt ++;
	}
	return false;	
}
头插法

// 头插法
bool Insert_Head(LinkList &L, Data element)
{
	LNode *cur = (LNode*)malloc(sizeof(LNode));
	cur->data = element;
	cur->next = L->next;
	L->next = cur;
	return true;
}
尾插法
// 尾插法
bool Insert_Tail(LinkList &L, Data element)
{
	LNode *p = L;
	while (p->next){
		p = p->next;
	}
	LNode *cur = (LNode*)malloc(sizeof(LNode));
	cur->data = element;
	cur->next = NULL;
	p->next = cur;
	return true;
}
输出单链表
// 输出单链表
void Print_List(LinkList &L)
{
	for (LNode* p = L->next; p != NULL; p = p->next)
	{
		printf("%d ", p->data.e);
	}
	printf("\n");
}

循环链表

优点：

从表中任意节点出发都能够找到其他结点。

注意：

当执行遍历操作时，条件与单链表不同，结束条件需要看当前节点的指针域是不是等于头结点。

链表定义：
typedef struct {
	int e;
} Data;

typedef struct Lnode {
	Data data; // 结点的数据域
	struct Lnode *next; // 结点的指针域
} LNode, *LinkList; // 定义了两种类型：LNode 为结构体类型；LinkList 为指向该结构体类型的指针类型。
链表操作：

带头指针的：

// 循环链表的初始化
bool InitList_L(LinkList &L) 
{
	L = (LinkList)malloc(sizeof(LNode));
	L->next = L;
	return true;
}
// 判断循环链表是否为空
bool IsEmpty_List(LinkList L)
{
	if (L->next == L) return true;
	return false;
}
// 循环链表的销毁
void Destroy_List(LinkList &L)
{
	LNode *p = L->next;
	while (p->next != L)
	{
		L = L->next;
		free(p);
		p = L->next;
	}
	free(L);
}
// 清空循环链表
void Clear_List(LinkList &L)
{
	LNode *p;
	while (L->next != L)
	{
		p = L->next;
		L->next = p->next;
		free(p);
	}
}
// 求循环链表的表长
int Caculate_Length(LinkList L)
{
	int len = 0;
	LNode *p = L;
	while (p->next != L)
	{
		len ++;
		p = p->next;
	}
	return len;
}
// 取值-取循环链表中第idx个元素的内容
bool GetElement(LinkList L, Data &e, int idx)
{
	int len = 0;
	LNode *p = L;
	while (p->next != L)
	{
		len ++;
		p = p->next;
		if (len == idx)
		{
			e = p->data;
			return true;
		}
	}
	
	return false;
}
// 按值查找-根据数据获取该数据所在位置
int GetIdx(LinkList L, Data &element)
{
	int len = 0;
	LNode *p = L;
	while (p->next != L)
	{
		len ++;
		p = p->next;
		if (p->data.e == element.e)
		{
			return len;
		}
	}
	return -1;
}
// 循环链表的插入-在第i个元素之前插入
bool Insert(LinkList &L, int idx, Data element)
{
	int len = 0;
	LNode *p = L;
	while (p->next != L)
	{
		if (len == idx - 1)
		{
			LNode *q = (LNode*)malloc(sizeof(LNode));
			q->data = element;
			q->next = p->next;
			p->next = q;
			return true;
		}
		len ++;
		p = p->next;
	}
	
	return false;
}
// 删除-删除第idx个元素
bool Delete(LinkList &L, int idx)
{
	int len = 0;
	LNode *p = L;
	while (p->next != L)
	{
		len ++;
		p = p->next;
		if (len == idx - 1)
		{
			LNode *q = p->next;
			p->next = q->next;
			free(q);
			return true;
		}
	}
	return false;
}

// 头插法
bool Insert_Head(LinkList &L, Data element)
{
	LNode *p = (LNode*)malloc(sizeof(LNode));
	p->data = element;
	p->next = L->next;
	L->next = p;
	return true;
}

// 尾插法
bool Insert_Tail(LinkList &L, Data element)
{
	LNode *p = L;
	while (p->next != L)
	{
		p = p->next;
	}
	LNode *q = (LNode*)malloc(sizeof(LNode));
	q->data = element;
	q->next = p->next;
	p->next = q;
	return true;
}
// 输出循环链表
void Print_List(LinkList &L)
{
	for (LNode* p = L->next; p != L; p = p->next)
	{
		printf("%d ", p->data.e);
	}
	printf("\n");
}

带尾指针的：

// 循环链表的初始化
bool InitList_R(LinkList &R) 
{
	R->next = R;
	return true;
}
// 判断循环链表是否为空
bool IsEmpty_List(LinkList R)
{
	if (R->next == R) return true;
	return false;
}
// 循环链表的销毁
void Destroy_List(LinkList &R)
{
	LNode *p;
	while (R->next != R)
	{
		p = R->next;
		R->next = p->next;
		free(p);
	}
	free(R);
}
// 清空循环链表
void Clear_List(LinkList &R)
{
	LNode *p;
	while (R->next != R)
	{
		p = R->next;
		R->next = p->next;
		free(p);
	}
}
// 求循环链表的表长
int Caculate_Length(LinkList R)
{
	LNode *p = R;
	int len = 0;
	while (p->next != R)
	{
		len ++;
		p = p->next;
	}
	return len;
}
// 取值-取循环链表中第idx个元素的内容
bool GetElement(LinkList R, Data &e, int idx)
{
	int len = 0;
	LNode *p = R;
	while (p->next != R)
	{
		len ++;
		p = p->next;
		if (len == idx)
		{
			e = p->data;
			return true;
		}
	}
	return false;	
}
// 按值查找-根据数据获取该数据所在位置
int GetIdx(LinkList R, Data &element)
{
	int len = 0;
	LNode *p = R;
	while (p->next != R)
	{
		len ++;
		p = p->next;
		if (p->data.e == element.e)
		{
			return len;
		}
	}
	return -1;
}	
// 循环链表的插入-在第i个元素之前插入
bool Insert(LinkList &R, int idx, Data element)
{
	int len = 0;
	LNode *p = R;
	while (p->next != R)
	{
		if (len == idx - 1)
		{
			LNode *q = (LNode*)malloc(sizeof(LNode));
			q->data = element;
			q->next = p->next;
			p->next = q;
			return true;
		}
		len ++;
		p = p->next;
	}
	
	return false;	
}
// 删除-删除第idx个元素
bool Delete(LinkList &R, int idx)
{
	int len = 0;
	LNode *p = R;
	while (p->next != R)
	{
		len ++;
		p = p->next;
		if (len == idx - 1)
		{
			LNode *q = p->next;
			p->next = q->next;
			free(q);
			return true;
		}
	}
	return false;	
}

// 头插法
bool Insert_Head(LinkList &R, Data element)
{
	LNode *p = (LNode*)malloc(sizeof(LNode));
	p->data = element;
	p->next = R->next;
	R->next = p;
	return true;
}

// 尾插法
bool Insert_Tail(LinkList &R, Data element)
{
	
	LNode *p = R;
	while (p->next != R)
	{
		p = p->next;
	}
	LNode *q = (LNode*)malloc(sizeof(LNode));
	q->data = element;
	q->next = R;
	p->next = q;
	return true;
}
// 输出循环链表
void Print_List(LinkList &R)
{
	for (LNode* p = R->next; p != R; p = p->next)
	{
		printf("%d ", p->data.e);
	}
	printf("\n");
}

双链表

数组模拟双链表：数组模拟双链表文章浏览阅读92次。数组模拟双链表_;.ir=k,8https://blog.csdn.net/m0_73569492/article/details/128704895?ops_request_misc=%257B%2522request%255Fid%2522%253A%25221c13d05d054d65bc8bd9b7e25466efa9%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=1c13d05d054d65bc8bd9b7e25466efa9&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~rank_v31_ecpm-1-128704895-null-null.nonecase&utm_term=%E5%8F%8C%E9%93%BE%E8%A1%A8&spm=1018.2226.3001.4450

链表定义
typedef struct {
	int e;
} Data;

typedef struct Lnode {
	struct Lnode *pre; // 指向前驱结点
	Data data; // 结点的数据域
	struct Lnode *next; // 指向后继结点
} LNode, *LinkList; // 定义了两种类型：LNode 为结构体类型；LinkList 为指向该结构体类型的指针类型。
链表操作
// 双链表的初始化
bool InitList_L(LinkList &L) 
{
	L = (LinkList)malloc(sizeof(LNode));
	L->pre = NULL;
	L->next = NULL;
	return true;
}
// 判断链表是否为空
bool IsEmpty_List(LinkList L)
{
	if (L->next == NULL) return true;
	return false;
}
// 双链表的销毁
void Destroy_List(LinkList &L)
{
	LNode *p;
	while (L)
	{
		p = L;
		L = L->next;
		free(p);
	}	
}
// 清空双链表
void Clear_List(LinkList &L)
{
	LNode *p;
	while (L->next != NULL) 
	{
		p = L->next;
		L->next = p->next;
		free(p);
	}	
}
// 求双链表的表长
int Caculate_Length(LinkList L)
{
	int cnt = 0;
	for (LNode* p = L->next; p != NULL; p = p->next)
		cnt ++;
		
	return cnt;
}
// 取值-取双链表中第idx个元素的内容
bool GetElement(LinkList L, Data &e, int idx)
{
	int cnt = 0;
	for (LNode* p = L->next; p != NULL; p = p->next)
	{
		 cnt ++;
		 if (cnt == idx) 
		 {
		 	e = p->data;
		 	return true;
		 }	
	}
	return false;
}
// 按值查找-根据数据获取该数据所在位置
int GetIdx(LinkList L, Data &element)
{
	int cnt = 0;
	for (LNode* p = L->next; p != NULL; p = p->next)
	{
		 cnt ++;
		 if (p->data.e == element.e) return cnt; 
	}
	return -1;	
}
// 双链表的插入-在第i个元素之前插入
bool Insert(LinkList &L, int idx, Data element)
{
	int cnt = 0;
	for (LNode* p = L; p->next != NULL; p = p->next)
	{
		 if (cnt == idx - 1)
		 {
		 	LNode *e = (LNode*)malloc(sizeof(LNode));
		 	e->data = element;
		 	e->next = p->next;
		 	e->pre = p;
		 	p->next->pre = e;
		 	p->next = e;
		 }
		 cnt ++;
	}	
	return false;	
}
// 删除-删除第idx个元素
bool Delete(LinkList &L, int idx)
{
	int cnt = 0;
	for (LNode* p = L; p != NULL; p = p->next)
	{
		 if (cnt == idx - 1)
		 {
		 	LNode *q = p->next;
		 	if (!q->next) 
		 	{
				p->next = NULL;
				free(q);
				return true; 	
			}
		 	p->next = q->next;
		 	q->next->pre = p;
		 	
		 	free(q);
		 	return true;
		 }
		 cnt ++;
	}
	return false;	
}

// 头插法
bool Insert_Head(LinkList &L, Data element)
{
	LNode *p = (LNode*)malloc(sizeof(LNode));
	p->data = element;
	if (L->next) 
	{
		p->pre = L;
		p->next = L->next;
		L->next->pre = p;
		L->next = p;
	}
	else
	{
		L->next = p;
		p->pre = L;
		p->next = NULL;
	}
	return true;
}

// 尾插法
bool Insert_Tail(LinkList &L, Data element)
{
	LNode *p = L;
	while (p->next != NULL){
		p = p->next;
	}
	// 在p后面插入cur
	LNode *cur = (LNode*)malloc(sizeof(LNode));
	cur->data = element;
	if (p->next)
	{
		cur->pre = p;
		cur->next = p->next;
		p->next->pre = cur;
		p->next = cur;
	}
	else
	{
		p->next = cur;
		cur->pre = p;
		cur->next = NULL;
	}
	return true;
}
// 输出链表
void Print_List(LinkList &L)
{
	for (LNode* p = L->next; p != NULL; p = p->next)
	{
		printf("%d ", p->data.e);
	}
	printf("\n");	
}

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

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

相关文章

实践：事件循环

实践：事件循环

实践&#xff1a;事件循环 代码示例 console.log(1); setTimeout(() > console.log(2), 0); Promise.resolve(3).then(res > console.log(res)); console.log(4);上述的代码的输出结果是什么 1和4肯定优先输出&#xff0c;因为他们会立即方式堆栈的执行上下文中执行&am…
阅读更多...
从零开始开发纯血鸿蒙应用之逻辑封装

从零开始开发纯血鸿蒙应用之逻辑封装

从零开始开发纯血鸿蒙应用 一、前言二、逻辑封装的原则三、实现 FileUtil1、统一的存放位置2、文件的增删改查2.1、文件创建与文件保存2.2、文件读取2.2.1、读取内部文件2.2.2、读取外部文件 3、文件删除 四、总结 一、前言 应用的动态&#xff0c;借助 UI 响应完成&#xff0…
阅读更多...
ESP32 I2S音频总线学习笔记（一）：初识I2S通信与配置基础

ESP32 I2S音频总线学习笔记（一）：初识I2S通信与配置基础

文章目录 简介为什么需要I2S&#xff1f;关于音频信号采样率分辨率音频声道 怎样使用I2S传输音频&#xff1f;位时钟BCLK字时钟WS串行数据SD I2S传输模型I2S通信格式I2S格式左对齐格式右对齐格式 i2s基本配置i2s 底层API加载I2S驱动设置I2S使用的引脚I2S读取数据I2S发送数据卸载…
阅读更多...
CSS 中 content换行符实现打点 loading 正在加载中的效果

CSS 中 content换行符实现打点 loading 正在加载中的效果

我们动态加载页面内容的时候&#xff0c;经常会使用“正在加载中…”这几个字&#xff0c;基本上&#xff0c;后面的 3 个点都是静态的。静态的问题在于&#xff0c;如果网络不流畅&#xff0c;加载时间比较长&#xff0c;就会给人有假死的 感觉&#xff0c;但是&#xff0c;如…
阅读更多...
25考研王道数据结构课后习题笔记

25考研王道数据结构课后习题笔记

声明&#xff1a;以下内容来自于B栈知名up主–白话拆解数据结构 回答&#xff1a;为什么要做这个&#xff0c;因为我这个学期学完了数据结构&#xff0c;而且这个数据结构是408的重头&#xff0c;为什么选择25的&#xff0c;因为这个25考研刚刚结束&#xff0c;25相对成熟&…
阅读更多...
小程序发版后，强制更新为最新版本

小程序发版后，强制更新为最新版本

为什么要强制更新为最新版本&#xff1f; 在小程序的开发和运营过程中&#xff0c;强制用户更新到最新版本是一项重要的策略&#xff0c;能够有效提升用户体验并保障系统的稳定性与安全性。以下是一些主要原因&#xff1a; 1. 功能兼容 新功能或服务通常需要最新版本的支持&…
阅读更多...
GRAPE——RLAIF微调VLA模型：通过偏好对齐提升机器人策略的泛化能力(含24年具身模型汇总)

GRAPE——RLAIF微调VLA模型：通过偏好对齐提升机器人策略的泛化能力(含24年具身模型汇总)

前言 24年具身前沿模型大汇总 过去的这两年&#xff0c;工作之余&#xff0c;我狂写大模型与具身的文章&#xff0c;加之具身大火&#xff0c;每周都有各种朋友通过CSDN私我及我司「七月在线」寻求帮助/指导(当然&#xff0c;也欢迎各大开发团队与我司合作共同交付&#xff09…
阅读更多...
0xc0000020错误代码怎么处理，Windows11、10坏图像错误0xc0000020的修复办法

0xc0000020错误代码怎么处理，Windows11、10坏图像错误0xc0000020的修复办法

“0xc0000020”是一种 Windows 应用程序错误代码&#xff0c;通常表明某些文件缺失或损坏。这可能是由于系统文件损坏、应用程序安装或卸载问题、恶意软件感染、有问题的 Windows 更新等原因导致的。 比如&#xff0c;当运行软件时&#xff0c;可能会出现类似“C:\xx\xxx.dll …
阅读更多...
pycharm+anaconda创建项目

pycharm+anaconda创建项目

pycharmanaconda创建项目 安装&#xff1a; Windows下PythonPyCharm的安装步骤及PyCharm的使用-CSDN博客 详细Anaconda安装配置环境创建教程-CSDN博客 创建项目&#xff1a; 开始尝试新建一个项目吧&#xff01; 选择好项目建设的文件夹 我的项目命名为&#xff1a;pyth…
阅读更多...
基于Pytorch和yolov8n手搓安全帽目标检测的全过程

基于Pytorch和yolov8n手搓安全帽目标检测的全过程

一.背景 还是之前的主题&#xff0c;使用开源软件为公司搭建安全管理平台&#xff0c;从视觉模型识别安全帽开始。主要参考学习了开源项目 https://github.com/jomarkow/Safety-Helmet-Detection&#xff0c;我是从运行、训练、标注倒过来学习的。由于工作原因&#xff0c;抽空…
阅读更多...
【PDF物流单据提取明细】批量PDF提取多个区域内容导出表格或用区域内容对文件改名，批量提取PDF物流单据单号及明细导出表格并改名的技术难点及小节

【PDF物流单据提取明细】批量PDF提取多个区域内容导出表格或用区域内容对文件改名，批量提取PDF物流单据单号及明细导出表格并改名的技术难点及小节

相关阅读及下载&#xff1a; PDF电子物流单据&#xff1a; 批量PDF提取多个区域局部内容重命名PDF或者将PDF多个局部内容导出表格&#xff0c;具体使用步骤教程和实际应用场景的说明演示https://mp.weixin.qq.com/s/uCvqHAzKglfr40YPO_SyNg?token720634989&langzh_CN扫描…
阅读更多...
JavaWeb开发（五）Servlet-ServletContext

JavaWeb开发（五）Servlet-ServletContext

1. ServletContext 1.1. ServletContext简介 1.1.1. ServletContext定义 ServletContext即Servlet上下文对象&#xff0c;该对象表示当前的web应用环境信息。 1.1.2. 获取ServletContext对象: &#xff08;1&#xff09;通过ServletConfig的getServletContext()方法可以得到…
阅读更多...
长时间序列预测算法---Informer

长时间序列预测算法---Informer

目录 一、传统的 Transformer 模型二、Informer原理2.1 Attention计算2.2 “积极”的Q筛选2.2.1 KL散度2.2.2 “懒惰”的q处理 2.3 Encoder结构2.4 Decoder结构2.4.1 Transformer的Decoder操作2.4.2 Informer的Decoder操作 2.5 Informer模型的改进 三、模型应用 时间序列相关参…
阅读更多...
点击取消按钮，console出来数据更改了，页面视图没有更新

点击取消按钮，console出来数据更改了，页面视图没有更新

点击取消按钮&#xff0c;console出来数据更改了&#xff0c;页面视图没有更新 前言 实现效果&#xff1a;点击取消按钮&#xff0c;页面视图全部为空&#xff0c; 遇到的问题&#xff1a; 点击取消按钮&#xff0c;console出来数据更改了&#xff0c;SchemaJson 都是默认值啦…
阅读更多...
RFID手持机与RFID工业平板在仓储物流管理系统中的选型

RFID手持机与RFID工业平板在仓储物流管理系统中的选型

概述 随着物联网技术在仓储物流管理系统中的普及&#xff0c;RFID手持机与RFID工业平板作为基于RFID技术手持式读写器的两种重要终端设备形态&#xff0c;得到了广泛应用。尽管RFID手持机与RFID工业平板都具备读写 RFID标签的基本功能&#xff0c;使用场景较为类似&#xff0c…
阅读更多...
UML之泛化、特化和继承

UML之泛化、特化和继承

在UML&#xff08;统一建模语言&#xff09;中&#xff0c;泛化&#xff08;Generalization&#xff09;和特化&#xff08;Specialization&#xff09;是面向对象思想中继承&#xff08;Inheritance&#xff09;关系的重要概念&#xff0c;它们描述类与类&#xff08;或用例与…
阅读更多...
vue 修改vant样式NoticeBar中的图标，不用插槽可以直接用图片

vue 修改vant样式NoticeBar中的图标，不用插槽可以直接用图片

使用文档中是可以直接使用图片链接的 :left-icon"require(../../assets/newImages/noticeImg.png)" <html> .... <NoticeBarmode""color"#C6C6C6"background""v-if"global_info.site_bulletin":left-icon"r…
阅读更多...
【漫话机器学习系列】028.CP

【漫话机器学习系列】028.CP

Mallows’ Cp&#xff1a;标准化公式解析与应用 Mallows’ Cp 是一种常用的模型选择工具&#xff0c;用于在一系列候选模型中权衡拟合度和复杂性&#xff0c;帮助我们选择性能最优的模型。本文将基于其标准化公式展开详细解析&#xff0c;并探讨其应用场景、实现方法、优点与局…
阅读更多...
vs 2022 中xml 粘贴为Class 中，序列化出来的xml 的使用

vs 2022 中xml 粘贴为Class 中，序列化出来的xml 的使用

上图是visual studio 2022 中使用的粘贴功能的菜单位置 在生成的xml 中&#xff0c;有些是类似如下类型的 [System.Serializable] [System.Xml.Serialization.XmlType] public class Item {private bool isVisibleField;private bool isVisibleFieldSpecified;[System.Xml.Se…
阅读更多...
数据库自增 id 过大导致前端时数据丢失

数据库自增 id 过大导致前端时数据丢失

可以看到&#xff0c;前端响应参数是没有丢失精度的 但是在接受 axios 请求参数时出现了精度丢失 解决方案一&#xff1a;改变 axios 字符编码 axios.defaults.headers[Content-Type] application/json;charsetUTF-8; 未解决 解决方案二&#xff1a;手动使用 json.parse() …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023