数据结构 | 线性表

news2024/11/22 14:51:00

 🔥Go for it!🔥
📝个人主页：按键难防
📫 如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步👀

📖系列专栏：数据结构与算法
🔥 如果感觉博主的文章还不错的话，还请 点赞👍🏻收藏⭐️ + 留言📝​支持 一下博主哦

目录

​​​​​​​​​​​​​​一.线性表

①顺序表(顺序存储)

具体操作

1.顺序表插入元素：

2.顺序表删除元素： 

3.遍历查找（按值）：

②链表（链式存储）

1.单链表

①单链表定义：

②头插法：

③尾插法：

具体操作

①按位查找（遍历）：

②按值查找：

③插入元素：

④删除操作 

​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​一.线性表

3e8573ac6503453c9c840d6c1fefaa86.png

 定义：由n(n≥0)个相同类型的元素组成的有序集合。（L=a1, a2, … , ai , ai+1, … , an）

线性表中元素个数n，称为线性表的长度。当n=0时，为空表。
a1是唯一的"第一个"数据元素，an是唯一的“最后一个”数据元素。
ai-1为a的直接前驱，ai+1为a的直接后继。


特点：

表中元素的个数是有限的。

表中元素的数据类型都相同。意味着每一个元素占用相同大小的空间
表中元素具有逻辑上的顺序性，在序列中各元素排序有其先后顺序

线性表第一个元素的位序是1，下标是0。

线性表是逻辑结构，表示元素之间一对一的相邻关系，用存储结构实现线性表就是顺序表或链表。

​​​​​​​​​​​​​​

a925b9a606f848fd8cfa60a35fc533df.png

①顺序表(顺序存储)

用顺序存储的方式实现线性表

定义方法（静态版本）：

#define MaxSize 50 //定义线性表的长度
typedef int ElemType;//重定义线性表中每个元素的类型，便于修改
typedef struct{
	ElemType data[MaxSize];//顺序表
	int len;//记录顺序表的当前长度
}SqList;//顺序表的类型定义

优点：可以随机存取（根据表头元素地址和序号）表中任意一个元素。存储密度高，每个结点只存储数据元素。

缺点： 插入和删除操作需要移动大量元素。线性表变化较大时，难以确定存储空间的容量。存储分配需要一整段连续的存储空间，不路灵活。 

具体操作

1.顺序表插入元素：

#define MaxSize 50 //定义线性表的长度
typedef int ElemType;//重定义线性表中每个元素的类型，便于修改
typedef struct{
	ElemType data[MaxSize];//顺序表
	int len;//记录顺序表的当前长度
}SqList;//顺序表的类型定义
bool ListInsert(SqList &L, int i, ElemType e)
{
	//判断i的范围是否有效
	if (i<1 || i>L.len + 1)
	{
		return false;
	}
	if (L.len>MaxSize) //当前存储空间已满，不能插入  
	{
		return false;
	}
	for (int j = L.len; j >= i; j--)
	{    //将第i个元素及其之后的元素后移
		L.data[j] = L.data[j - 1];
	}
	L.data[i - 1] = e;  //在位置i处放入e
	L.len++;      //长度加1
	return true;
}
void PrintfList(SqList L)
{
	int i =0;
	for (i = 0; i < L.len; i++)
	{
		printf("%d",L.data[i]);
	}
	printf("\n");
}
int main()
{
	SqList L;
	bool ret;//布尔类型返回值
	L.data[0] = 1;
	L.data[1] = 2;
	L.data[2] = 3;
	L.data[3] = 4;
	L.data[4] = 5;
    L.len = 5;//记录顺序表的当前长度
	ret = ListInsert(L,2,60);//在第二个元素位置插入60
	if (ret)
	{
		printf("插入成功\n");
		PrintfList(L);
	}
	else
	{
		printf("插入失败\n");
	}
	return 0;
}

 b2d31c8d248b4d51a211061fd8de8992.png

bf48b7f6a8a840be9b9de2357588e6e4.png

2.顺序表删除元素： 

#include<stdio.h>
#define MaxSize 50 //定义线性表的长度
typedef int ElemType;//重定义线性表中每个元素的类型，便于修改
typedef struct{
	ElemType data[MaxSize];//顺序表
	int len;//记录顺序表的当前长度
}SqList;//顺序表的类型定义
bool ListDelete(SqList &L, int i, ElemType &e)
{ //&e是为了将删去的值赋给e
	//判断i的范围是否有效
	int j = 0;
	if (i<1 || i>L.len)
	{
		return false;
	}
	e = L.data[i - 1];    //将被删除的元素赋值给e
	for (j=i; j<=L.len; j++)
	{    //将第i个后的元素前移
			L.data[j - 1] = L.data[j];
	}
		L.len--;      //长度减1
		return true;
}
void PrintfList(SqList L)
{
	int i =0;
	for (i = 0; i < L.len; i++)
	{
		printf("%d",L.data[i]);
	}
	printf("\n");
}
int main()
{
	SqList L;
	bool ret;//布尔类型返回值
	L.data[0] = 1;
	L.data[1] = 2;
	L.data[2] = 3;
	L.data[3] = 4;
	L.data[4] = 5;
    L.len = 5;//记录顺序表的当前长度
	ElemType del;//存储删去的元素
	ret = ListDelete(L,1,del);//删除第一个元素
	if (ret)
	{
		printf("删除成功\n");
		PrintfList(L);
	}
	else
	{
		printf("删除            失败\n");
	}
	return 0;
}

 336ad493e77240e682ade1ed79001372.png561cc26c4e304e99a1dee029c644b9d7.png

3.遍历查找（按值）：

#include<stdio.h>
#define MaxSize 50 //定义线性表的长度
typedef int ElemType;//重定义线性表中每个元素的类型，便于修改
typedef struct{
	ElemType data[MaxSize];//顺序表
	int len;//记录顺序表的当前长度
}SqList;//顺序表的类型定义
int LocateElem(SqList L, ElemType e)
{
	int i = 0;
	for (i = 0; i < L.len; i++)//遍历查找
	{
		if (L.data[i] == e)
			return i + 1;
	}//数组下标为i的元素值等于e，返回其位序i+1
	return 0;//退出循环，说明查找失败
}
void PrintfList(SqList L)
{
	int i = 0;
	for (i = 0; i < L.len; i++)
	{
		printf("%d ", L.data[i]);
	}
	printf("\n");
}
int main()
{
	SqList L;
	int ret;//布尔类型返回值
	L.data[0] = 1;
	L.data[1] = 2;
	L.data[2] = 3;
	L.data[3] = 60;
	L.data[4] = 5;
	L.len = 5;//记录顺序表的当前长度
	ret = LocateElem(L,60);
	if (ret)
	{
		printf("查找成功\n");
		printf("位序是%d\n", ret);
	}
	else
	{
		printf("查找失败\n");
	}
	return 0;
}

160dc2eef2c64c3788f32d59cfce7666.png

动态版本：

#define MaxSize 50 //定义线性表的长度
typedef struct{
    ElemType* data;//顺序表的元素
    int len;//顺序表的当前长度
}SqList;//顺序表的类型定义
L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize)
//malloc函数申请一片连续的存储空间，大小为sizeof(ElemType)*InitSize
//用完要用free函数释放原来的内存空间

②链表（链式存储）

用链式存储的方式实现线性表。

1.单链表

头指针：链表中第一个结点的存储位置，用来标识单链表。

头结点：在单链表第一个结点之前附加的一个结点，为了操作上的方便。

若链表有头结点，则头指针永远指向头结点，没有头结点则指向第一个结点，不论链表是否为空，头指针均不为空，头指针是链表的必须元素，他标识一个链表.

头结点是为了操作的方便而设立的，其数据域一般为空，或者存放链表的长度，

有头结点后，对在第一结点前插入和删除第一结点的操作就统一了，不需要频繁重置头指针，但头节点不是必须的。

优点：

插入和删除操作不需要移动元素，只需要修改指针。不需要大量的连续存储空间。

缺点：

单链表附加指针域。也存在浪费存储空间的缺点。查找操作时需要从表头开始遍历，依次查找，不能随机

①单链表定义：

typedef int ElemType;//重定义链表表中每个元素的类型，便于修改
typedef struct LNode//定义单链表结点类型
{
	ElemType data; //数据域
	struct LNode *next;//指针域，指向下一个结点。
}LNode, *LinkList;
解释：typedef重命名了两个数据类型，
分别是将struct LNode重命名为LNode，将struct LNode*重命名为LinkList
前者是个结构体，后者是个指向该结构体的指针
用LNode创建变量，就是创建一个结构体
用LinkList创建变量，就是指向这个结构体的指针

②头插法：

1b16993672c146a0b3f3ab4d3864250e.jpeg

 重点在灵活变化头结点的指针域，插进来一个，我就把头结点指针域原值赋给插进来结点的指针域，然后头结点的指针域改为新插进来结点的指针。

#include<stdio.h>
#include<stdlib.h>
#define MaxSize 50 //定义线性表的长度
typedef int ElemType;//重定义链表表中每个元素的类型，便于修改
typedef struct LNode//定义单链表结点类型
{
	ElemType data; //数据域
	struct LNode* next;//指针域，指向下一个结点（结构体)。
}LNode, *LinkList;
LinkList list_head_insert(LinkList &L)
{
	L = (LinkList)malloc(sizeof(LNode));//用动态内存开辟初始化头指针，指向头结点
	L->next = NULL;
	ElemType x;//头结点不存数据,随机初始化即可
	scanf("%d", &x);
	LinkList s;//结构体指针，用来指向申请的新节点s
	while (x!= 9999)//输入9999停止
	{
		s = (LinkList)malloc(sizeof(LNode));//为新节点申请空间
		s->data = x;//存数据
		s->next = L->next;
		L->next = s;//将插入的节点与头节点连接起来
		scanf("%d", &x);
	}
	return L;//链表建立完毕，返回头指针
}
void printf_list(LinkList L)
{
	L=L->next;
	while (L!= NULL)
	{
		printf("%3d ", L->data);
		L=L->next;
	}
	printf("\n");
}
int main()
{
	LinkList  L;//L是链表头指针，此时没初始化，还没指向头结点
	list_head_insert(L);
	printf_list(L);//链表打印
	return 0;
}

③尾插法：

44d56d1b9ad84b564a33cc8a502ae699.jpeg

r一直在充当中转站的角色。 

#include <stdio.h>
#include <stdlib.h>
typedef int ElemType;
typedef struct LNode{
	ElemType data;
	struct LNode *next;//指向下一个结点
}LNode, *LinkList;
//尾插法新建链表
LinkList list_tail_insert(LinkList &L)
{
	L = (LinkList)malloc(sizeof(LNode));//带头节点的链表
	L->next = NULL;
	ElemType x;
	scanf("%d", &x);
	LinkList s, r = L;//s是指向新结点，r始终指向链表尾部。
	while (x != 9999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;//让尾部结点指向新结点
		r = s;//r=s是确保r指向的是新的表尾结点
		scanf("%d", &x);
	}
	r->next = NULL;//尾结点的 next 指针赋值为 NULL
	return L;
}
//打印链表中每个结点的值
void print_list(LinkList L)
{
	L = L->next;
	while (L != NULL)
	{
		printf("%3d ", L->data);//打印当前结点数据
		L = L->next;//指向下一个结点
	}
	printf("\n");
}
int main()
{
	LinkList L;//链表头，是结构体指针类型
	list_tail_insert(L);//输入数据可以为 3 4 5 6 7 9999
	print_list(L);//链表打印
	return 0;
}

具体操作

①按位查找（遍历）：

单链表只能从前往后查找

L的位置是0

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef int ElemType;
typedef struct LNode
{
	ElemType data;
	struct LNode *next;//指向下一个结点
}LNode, *LinkList;
//尾插法新建链表
LinkList list_tail_insert(LinkList &L)
{
	L = (LinkList)malloc(sizeof(LNode));//带头节点的链表
	L->next = NULL;
	ElemType x;
	scanf("%d", &x);
	LinkList s, r = L;//s是指向新结点，r始终指向链表尾部。
	while (x != 9999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;//让尾部结点指向新结点
		r = s;//r 指向新的表尾结点
		scanf("%d", &x);
	}
	r->next = NULL;//尾结点的 next 指针赋值为 NULL
	return L;
}
//打印链表中每个结点的值
void print_list(LinkList L)
{
	L = L->next;
	while (L != NULL)
	{
		printf("%3d ", L->data);//打印当前结点数据
		L = L->next;//指向下一个结点
	}
	printf("\n");
}
LinkList GetElem(LinkList L, int i)
{
	int j = 0;	
	if (i < 0)
	{
		return NULL;
	}	
    for(j=0; L&&j<i;j++)
    {
         L =L->next;
     }
	return L;//返回查找到的结点
}
int main()
{
	LinkList L, search;//链表头，是结构体指针类型
	list_tail_insert(L);
	print_list(L);//链表打印
    search = GetElem(L, 2);
	if (search != NULL)
	{
		printf("按序号查找成功\n");
		printf("该序号的值为%d\n", search->data);
		return 0;
	}
}

②按值查找：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef int ElemType;
typedef struct LNode
{
	ElemType data;
	struct LNode *next;//指向下一个结点
}LNode, *LinkList;
//尾插法新建链表
LinkList list_tail_insert(LinkList &L)
{
	L = (LinkList)malloc(sizeof(LNode));//带头节点的链表
	L->next = NULL;
	ElemType x;
	scanf("%d", &x);
	LinkList s, r = L;//s是指向新结点，r始终指向链表尾部。
	while (x != 9999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;//让尾部结点指向新结点
		r = s;//r 指向新的表尾结点
		scanf("%d", &x);
	}
	r->next = NULL;//尾结点的 next 指针赋值为 NULL
	return L;
}
//打印链表中每个结点的值
void print_list(LinkList L)
{
	L = L->next;
	while (L != NULL)
	{
		printf("%3d ", L->data);//打印当前结点数据
		L = L->next;//指向下一个结点
	}
	printf("\n");
}
LinkList LocateElem(LinkList L, ElemType e)
{
	while (L)
	{
		if (L->data == e)//如果相等直接返回那个结点
		{
			return L;
		}
		L = L->next;
	}
}
int main()
{
	LinkList L, search;//链表头，是结构体指针类型
	list_tail_insert(L);
	print_list(L);//链表打印
	search = LocateElem(L, 6);//按值查询
	if (search != NULL)
	{
		printf("按值查找成功\n");
		printf("%d\n", search->data);
	}
}

③插入元素：

在第i个节点插入某元素，那我就借助先按位查找到第i-1个节点，然后将i-1的指针域赋给要插入的指针域，将i-1节点的指针域改为新插入节点的位置

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef int ElemType;
typedef struct LNode
{
	ElemType data;
	struct LNode *next;//指向下一个结点
}LNode, *LinkList;
//尾插法新建链表
LinkList list_tail_insert(LinkList &L)
{
	L = (LinkList)malloc(sizeof(LNode));//带头节点的链表
	L->next = NULL;
	ElemType x;
	scanf("%d", &x);
	LinkList s, r = L;//s是指向新结点，r始终指向链表尾部。
	while (x != 9999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;//让尾部结点指向新结点
		r = s;//r 指向新的表尾结点
		scanf("%d", &x);
	}
	r->next = NULL;//尾结点的 next 指针赋值为 NULL
	return L;
}
//打印链表中每个结点的值
void print_list(LinkList L)
{
	L = L->next;
	while (L != NULL)
	{
		printf("%3d ", L->data);//打印当前结点数据
		L = L->next;//指向下一个结点
	}
	printf("\n");
}
//按位查找
LinkList GetElem(LinkList L, int i)
{
	int j = 0;
	if (i < 0)
	{
		return NULL;
	}
    for(j=0; L&&j<i;j++)
    {
         L =L->next;
     }
	return L;//返回查找到的结点
}
//插入操作
bool ListFrontInsert(LinkList L, int i, ElemType e)
{
	LinkList p = GetElem(L, i - 1);
	if (NULL == p)
	{
		return false;
	}
	LinkList s = (LNode*)malloc(sizeof(LNode));//为新插入的结点申请空间
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}
int main()
{
	LinkList L, search;//链表头，是结构体指针类型
	list_tail_insert(L);
	print_list(L);//链表打印
	ListFrontInsert(L, 2, 99);//新结点插入第2个位置,值为99
	print_list(L);
}

④删除操作 

删除第i个节点，借助按位查找找到第i-1个，然后将该节点的指针域赋给中间变量，便于后续释放，然后将第i个节点的指针域赋给i-1

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef int ElemType;
typedef struct LNode
{
	ElemType data;
	struct LNode *next;//指向下一个结点
}LNode, *LinkList;
//尾插法新建链表
LinkList list_tail_insert(LinkList &L)
{
	L = (LinkList)malloc(sizeof(LNode));//带头节点的链表
	L->next = NULL;
	ElemType x;
	scanf("%d", &x);
	LinkList s, r = L;//s是指向新结点，r始终指向链表尾部。
	while (x != 9999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;//让尾部结点指向新结点
		r = s;//r 指向新的表尾结点
		scanf("%d", &x);
	}
	r->next = NULL;//尾结点的 next 指针赋值为 NULL
	return L;
}
//打印链表中每个结点的值
void print_list(LinkList L)
{
	L = L->next;
	while (L != NULL)
	{
		printf("%3d ", L->data);//打印当前结点数据
		L = L->next;//指向下一个结点
	}
	printf("\n");
}
//按位查找
LinkList GetElem(LinkList L, int i)
{
	int j = 0;
	if (i < 0)
	{
		return NULL;
	}
    for(j=0; L&&j<i;j++)
    {
         L =L->next;
     }
	return L;//返回查找到的结点
}
//删除操作
bool ListFrontInsert(LinkList L, int i, ElemType e)
{
	LinkList p = GetElem(L, i - 1);
	if (NULL == p)
	{
		return false;
	}
       LinkList q;//用来存储删除的节点，便于释放动态空间
       q=p->next;
       p->next=q->next;//断链
       free（q）//释放对应节点的空间
       return true;
}
int main()
{
	LinkList L, search;//链表头，是结构体指针类型
	list_tail_insert(L);
	print_list(L);//链表打印
       ListDelete(L,4);
       print_list(L);//链表打印
}

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

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

相关文章

Wise-IoU 作者导读：基于动态非单调聚焦机制的边界框损失

Wise-IoU 作者导读：基于动态非单调聚焦机制的边界框损失

论文地址&#xff1a;Wise-IoU: Bounding Box Regression Loss with Dynamic Focusing Mechanism GitHub&#xff1a;https://github.com/Instinct323/wiou 摘要&#xff1a;目标检测作为计算机视觉的核心问题&#xff0c;其检测性能依赖于损失函数的设计。边界框损失函数作为…
阅读更多...
153、【动态规划】leetcode ——416. 分割等和子集：滚动数组（C++版本）

153、【动态规划】leetcode ——416. 分割等和子集：滚动数组（C++版本）

题目描述 原题链接&#xff1a;1049. 最后一块石头的重量 II 解题思路 本题要找的是最小重量&#xff0c;我们可以将石头划分成两个集合&#xff0c;当两个集合的重量越接近时&#xff0c;相减后&#xff0c;可达到的装量就会是最小&#xff0c;此时本题的思路其实就类似于 4…
阅读更多...
【光伏功率预测】基于EMD-PCA-LSTM的光伏功率预测模型（Matlab代码实现）

【光伏功率预测】基于EMD-PCA-LSTM的光伏功率预测模型（Matlab代码实现）

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭&a…
阅读更多...
MSI_MSI-X中断之体验与使用

MSI_MSI-X中断之体验与使用

MSI_MSI-X中断之体验与使用 文章目录MSI_MSI-X中断之体验与使用1. 怎么发出MSI/MSI-X中断1.1 在RK3399上体验1.1.1 安装工具1.1.2 查看设备MSI-X信息1.1.3 验证MSI-X信息2. 怎么使用MSI/MSI-X3. MSI/MSI-X中断源码分析3.1 IRQ Domain创建流程3.1.1 GIC3.1.2 ITS3.1.3 PCI MSI3.…
阅读更多...
【Flutter】【Unity】使用 Flutter + Unity 构建（AR 体验工具包）

【Flutter】【Unity】使用 Flutter + Unity 构建（AR 体验工具包）

使用 Flutter Unity 构建&#xff08;AR 体验工具包&#xff09;【翻译】 原文&#xff1a;https://medium.com/potato/building-with-flutter-unity-ar-experience-toolkit-6aaf17dbb725 由于屡获殊荣的独立动画工作室 Aardman 与讲故事的风险投资公司 Fictioneers&#x…
阅读更多...
最大公约数：常用的四大算法求解最大公约数，分解质因数法、短除法、辗转相除法、更相减损法。

最大公约数：常用的四大算法求解最大公约数，分解质因数法、短除法、辗转相除法、更相减损法。

常用的四大算法求解最大公约数&#xff0c;分解质因数法、短除法、辗转相除法、更相减损法。 (本文获得CSDN质量评分【91】)【学习的细节是欢悦的历程】Python 官网&#xff1a;https://www.python.org/ Free&#xff1a;大咖免费“圣经”教程《 python 完全自学教程》&#x…
阅读更多...
网络基础-虚拟化工具-网桥

网络基础-虚拟化工具-网桥

系列文章目录 本系列文章主要是回顾和学习工作中常用的网络基础命令&#xff0c;在此记录以便于回顾。 该篇文章主要是讲解虚拟化的工具网桥相关的概念和常用命令 提示&#xff1a;写完文章后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录系…
阅读更多...
C++之多态【详细总结】

C++之多态【详细总结】

前言 想必大家都知道面向对象的三大特征&#xff1a;封装&#xff0c;继承&#xff0c;多态。封装的本质是&#xff1a;对外暴露必要的接口&#xff0c;但内部的具体实现细节和部分的核心接口对外是不可见的&#xff0c;仅对外开放必要功能性接口。继承的本质是为了复用&#x…
阅读更多...
MySQL（主从、半同步、组复制、MHA高可用）

MySQL（主从、半同步、组复制、MHA高可用）

文章目录一、MySQL源码编译以及初始化二、mysql主从复制、半同步MySQL组复制MySQL读写分离MHA高可用一、MySQL源码编译以及初始化 源码编译使用cmake&#xff0c;所以要提前安装cmake&#xff0c;完成之后make install即可 这里要创建mysql用户&#xff0c;以及用普通用户方式…
阅读更多...
电子秤专用模拟数字（AD）转换器芯片HX711介绍

电子秤专用模拟数字（AD）转换器芯片HX711介绍

HX711简介HX711是一款专为高精度电子秤而设计的24 位A/D 转换器芯片。与同类型其它芯片相比&#xff0c;该芯片集成了包括稳压电源、片内时钟振荡器等其它同类型芯片所需要的外围电路&#xff0c;具有集成度高、响应速度快、抗干扰性强等优点。降低了电子秤的整机成本&#xff…
阅读更多...
分享112个JS菜单导航，总有一款适合您

分享112个JS菜单导航，总有一款适合您

分享112个JS菜单导航&#xff0c;总有一款适合您 112个JS菜单导航下载链接&#xff1a;https://pan.baidu.com/s/1Dm73d2snbu15hZErJjTXxg?pwdfz1c 提取码&#xff1a;fz1c Python采集代码下载链接&#xff1a;https://wwgn.lanzoul.com/iKGwb0kye3wj base_url "h…
阅读更多...
【游戏逆向】RPG游戏背包镶嵌系统分析

【游戏逆向】RPG游戏背包镶嵌系统分析

镶嵌系统是很多3D游戏都有的功能&#xff0c;玩家可以向镶嵌槽内附加宝石来提升装备的属性&#xff0c;这也直接提升了物品的价值。在一些扫拍卖和摆摊的外挂中经常利用这个属性来低价购入高价值装备。以这款游戏为例&#xff0c;我们来对装备上的镶嵌槽和镶嵌宝石进行分析。 …
阅读更多...
Nacos，一款非常优秀的注册中心(附视频)

Nacos，一款非常优秀的注册中心(附视频)

Nacos 核心源码精讲 - IT贱男 - 掘金小册全方位源码精讲&#xff0c;深度剖析 Nacos 注册中心和配置中心的核心思想。「Nacos 核心源码精讲」由IT贱男撰写&#xff0c;375人购买https://s.juejin.cn/ds/BuC3Vs9/ 先简单说两句 你好&#xff0c;很高兴你能够点开本小册&#x…
阅读更多...
python 的 if 语句如何使用说明

python 的 if 语句如何使用说明

文章目录1. 一个示例2. 条件测试2.1 检查是否相等2.2 检查是否相等时不考虑大小写2.3 检查是否不相等2.4 比较数字2.5 检查多个条件2.6 布尔表达式3. if 语句4. 使用 if 语句处理列表1. 一个示例 关于 if 条件语句的使用&#xff0c;我们来写一个示例进行说明&#xff1a; #写…
阅读更多...
6.14 Rayleigh商

6.14 Rayleigh商

定义 矩阵在某个向量处的瑞利商Rayleigh quotient是这样定义的: ρ(x):xHAxxHx\rho(x) :\frac{x^HAx}{x^Hx} ρ(x):xHxxHAx​   这个怎么理解呢?上面是埃尔米特内积的表达式&#xff0c;下面是标准埃尔米特内积。但是矩阵不一定是对称阵&#xff0c;如果不是复数的话&#x…
阅读更多...
ChatGPT 这个风口，普通人怎么抓住：比如APP集成ChatGPT，公众号集成ChatGPT...

ChatGPT 这个风口，普通人怎么抓住：比如APP集成ChatGPT，公众号集成ChatGPT...

文章目录1. 引出问题2. 简单介绍ChatGPT2.1 ChatGPT是什么2.2 如何使用ChatGPT3. 普通人利用ChatGPT 变现方式1. 引出问题 最近几天OpenAI发布的ChatGPT聊天机器人如日中天&#xff0c;连着上了各个平台的热搜榜。 很多平台也都已集成了ChatGPT&#xff0c;比如csdn的客户端A…
阅读更多...
json-server使用

json-server使用

文章目录json-server使用简介安装json-server启动json-server操作创建数据库查询数据增加数据删除数据修改数据putpatch配置静态资源静态资源首页资源json-server使用 简介 github地址 安装json-server npm install -g json-server启动json-server json-server --watch db…
阅读更多...
Linux系统位运算函数以及相应CPU ISA实现收录

Linux系统位运算函数以及相应CPU ISA实现收录

以32位数据的二进制表示为例&#xff0c;习惯的写法是LSB在左&#xff0c;MSB在右&#xff0c;注意BIT序和大小端的字节序没有关系。Linux和BIT操作有关的接口在定义在头文件bitops.h中&#xff0c;bitops.h定义有两层&#xff0c;通用层和架构层&#xff0c;对应两个bitops.h&…
阅读更多...
【重要】2023年上半年有三AI新课程规划出炉，讲师持续招募中！

【重要】2023年上半年有三AI新课程规划出炉，讲师持续招募中！

2023年正式起航&#xff0c;想必大家都已经完全投入到了工作状态中&#xff0c;有三AI平台今年将在已有内容的基础上&#xff0c;继续进行新课程开发&#xff0c;本次我们来介绍今年上半年的课程计划&#xff0c;以及新讲师招募计划。2023年新上线课程我们平台的课程当前分为两…
阅读更多...
【Python爬虫案例】批量采集网站壁纸，实现自动更换桌面壁纸

【Python爬虫案例】批量采集网站壁纸，实现自动更换桌面壁纸

前言 美照天天换&#xff0c;才不会腻 不知道你们是不是这样&#xff0c;我的手机壁纸电脑壁纸&#xff0c;隔三岔五就喜欢换&#xff0c;看久了 我就腻了&#xff0c;索性就用python把这个网站的壁纸都采集下来&#xff0c;顺便再让电脑自动更换我的桌面壁纸 ~ 一篇文章教会…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023