单链表专题

news2024/11/25 6:42:57

文章目录

  • 目录
    • 1. 链表的概念及结构
    • 2. 实现单链表
      • 2.1 链表的打印
      • 2.2 链表的尾插
      • 2.3 链表的头插
      • 2.4 链表的尾删
      • 2.5 链表的头删
      • 2.6 查找
      • 2.7 在指定位置之前插入数据
      • 2.8 在指定位置之后插入数据
      • 2.9 删除pos节点
      • 2.10 删除pos之后的节点
      • 2.11 销毁链表
    • 3. 链表的分类

目录

  • 链表的概念及结构
  • 实现单链表
  • 链表的分类

1. 链表的概念及结构

概念：

链表是⼀种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的（链表在逻辑上是连续的，在物理结构上不一定连续） 。

链表的结构
链表是由一个一个节点（结点）组成的，一个节点由两个部分组成：要存储的数据 + 指针（结构体指针）

因此，只要定义节点的结构，就等于定义了链表：

typedef int SLTDataType;

//链表是由节点组成
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

2. 实现单链表

2.1 链表的打印

void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;

	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}

	printf("NULL\n");
}

2.2 链表的尾插

void SLTPushBack(SLTNode* phead, SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	newnode->data = x;
	newnode->next = NULL;
	
	//链表为空，新节点作为phead
	if (NULL == phead)
	{
		phead = newnode;
		return;
	}
	
	//链表不为空，找尾节点
	SLTNode* ptail = phead;

	while (ptail->next)
	{
		ptail = ptail->next;
	}

	//ptail就是尾节点
	ptail->next = newnode;
}

这样写是错误的！当一开始链表为空时，尾插的节点就变成了第一个节点，因此要把phead中的NULL改为第一个节点的地址，所以要传phead的地址，而不是传值。

应该这样写：

//因为头插、尾插、指定位置插入都需要申请新节点，所以单独封装成一个函数
SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	
	if (NULL == newnode)
	{
		perror("malloc fail!");
		exit(1);
	}

	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	SLTNode* newnode = SLTBuyNode(x);

	//链表为空，新节点作为phead
	if (NULL == *pphead)
	{
		*pphead = newnode;
		return;
	}

	//链表不为空，找尾节点
	SLTNode* ptail = *pphead;

	while (ptail->next)
	{
		ptail = ptail->next;
	}

	//ptail就是尾节点
	ptail->next = newnode;
}

2.3 链表的头插

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	SLTNode* newnode = SLTBuyNode(x);

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

2.4 链表的尾删

void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);
	//链表不能为空
	assert(*pphead);

	//链表不为空
	//链表只有一个节点，有多个节点
	if (NULL == (*pphead)->next)
	{
		free(*pphead);
		*pphead = NULL;
		return;
	}

	SLTNode* ptail = *pphead;
	SLTNode* prev = NULL;

	while (ptail->next)
	{
		prev = ptail;
		ptail = ptail->next;
	}

	prev->next = NULL;
	//销毁尾节点
	free(ptail);
	ptail = NULL;
}

2.5 链表的头删

void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);
	//链表不能为空
	assert(*pphead);

	//让第二个节点成为新的头
	//把旧的头节点释放掉
	SLTNode* next = (*pphead)->next;//->的优先级高于*
	free(*pphead);
	*pphead = next;
}

2.6 查找

SLTNode* SLTFind(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	//遍历链表
	SLTNode* pcur = *pphead;

	while (pcur) //等价于pcur != NULL
	{
		if (pcur->data == x)
		{
			return pcur;
		}

		pcur = pcur->next;
	}

	//没有找到
	return NULL;
}

2.7 在指定位置之前插入数据

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	//要加上链表不能为空
	assert(*pphead);

	SLTNode* newnode = SLTBuyNode(x);

	//pos刚好是头节点
	if (pos == *pphead)
	{
		//头插
		SLTPushFront(pphead, x);
		return;
	}

	//pos不是头节点的情况
	SLTNode* prev = *pphead;

	while (prev->next != pos)
	{
		prev = prev->next;
	}

	//prev -> newnode -> pos
	prev->next = newnode;
	newnode->next = pos;
}

2.8 在指定位置之后插入数据

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	SLTNode* newnode = SLTBuyNode(x);

	newnode->next = pos->next;
	pos->next = newnode;
}

2.9 删除pos节点

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);

	//pos刚好是第一个节点，没有前驱节点，执行头删
	if (*pphead == pos)
	{
		//头删
		SLTPopFront(pphead);
		return;
	}

	SLTNode* prev = *pphead;

	while (prev->next != pos)
	{
		prev = prev->next;
	}

	prev->next = pos->next;
	free(pos);
	pos = NULL;
}

2.10 删除pos之后的节点

void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	//pos->next不能为空
	assert(pos->next);

	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

2.11 销毁链表

void SListDesTroy(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);

	SLTNode* pcur = *pphead;

	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}

	*pphead = NULL;
}

完整代码：

//SList.h

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

typedef int SLTDataType;

//链表是由节点组成
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

void SLTPrint(SLTNode* phead);

//链表的头插、尾插
//void SLTPushBack(SLTNode* phead, SLTDataType x);//err
void SLTPushBack(SLTNode** pphead, SLTDataType x);
void SLTPushFront(SLTNode** pphead, SLTDataType x);

//链表的头删、尾删
void SLTPopBack(SLTNode** pphead);
void SLTPopFront(SLTNode** pphead);

//查找
SLTNode* SLTFind(SLTNode** pphead, SLTDataType x);

//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos);

//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos);

//销毁链表
void SListDesTroy(SLTNode** pphead);

//SList.c

#include "SList.h"

void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;

	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}

	printf("NULL\n");
}

//因为头插、尾插、指定位置插入都需要申请新节点，所以单独封装成一个函数
SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	
	if (NULL == newnode)
	{
		perror("malloc fail!");
		exit(1);
	}

	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	SLTNode* newnode = SLTBuyNode(x);

	//链表为空，新节点作为phead
	if (NULL == *pphead)
	{
		*pphead = newnode;
		return;
	}

	//链表不为空，找尾节点
	SLTNode* ptail = *pphead;

	while (ptail->next)
	{
		ptail = ptail->next;
	}

	//ptail就是尾节点
	ptail->next = newnode;
}


void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	SLTNode* newnode = SLTBuyNode(x);

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


void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);
	//链表不能为空
	assert(*pphead);

	//链表不为空
	//链表只有一个节点，有多个节点
	if (NULL == (*pphead)->next)
	{
		free(*pphead);
		*pphead = NULL;
		return;
	}

	SLTNode* ptail = *pphead;
	SLTNode* prev = NULL;

	while (ptail->next)
	{
		prev = ptail;
		ptail = ptail->next;
	}

	prev->next = NULL;
	//销毁尾节点
	free(ptail);
	ptail = NULL;
}


void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);
	//链表不能为空
	assert(*pphead);

	//让第二个节点成为新的头
	//把旧的头节点释放掉
	SLTNode* next = (*pphead)->next;//->的优先级高于*
	free(*pphead);
	*pphead = next;
}


//查找
SLTNode* SLTFind(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	//遍历链表
	SLTNode* pcur = *pphead;

	while (pcur) //等价于pcur != NULL
	{
		if (pcur->data == x)
		{
			return pcur;
		}

		pcur = pcur->next;
	}

	//没有找到
	return NULL;
}


//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	//要加上链表不能为空
	assert(*pphead);

	SLTNode* newnode = SLTBuyNode(x);

	//pos刚好是头节点
	if (pos == *pphead)
	{
		//头插
		SLTPushFront(pphead, x);
		return;
	}

	//pos不是头节点的情况
	SLTNode* prev = *pphead;

	while (prev->next != pos)
	{
		prev = prev->next;
	}

	//prev -> newnode -> pos
	prev->next = newnode;
	newnode->next = pos;
}

//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	SLTNode* newnode = SLTBuyNode(x);

	newnode->next = pos->next;
	pos->next = newnode;
}


//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);

	//pos刚好是第一个节点，没有前驱节点，执行头删
	if (*pphead == pos)
	{
		//头删
		SLTPopFront(pphead);
		return;
	}

	SLTNode* prev = *pphead;

	while (prev->next != pos)
	{
		prev = prev->next;
	}

	prev->next = pos->next;
	free(pos);
	pos = NULL;
}

//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	//pos->next不能为空
	assert(pos->next);

	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}


//销毁链表
void SListDesTroy(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);

	SLTNode* pcur = *pphead;

	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}

	*pphead = NULL;
}

//Test.c

//int removeElement(int* nums, int numsSize, int val)
//{
//	//定义两个变量
//	int src = 0, dst = 0;
//
//	while (src < numsSize)
//	{
//		//nums[src] == val,src++
//		//否则赋值,src和dst都++
//		if (nums[src] == val)
//		{
//			src++;
//		}
//		else
//		{
//			//说明src指向位置的值不等于val
//			nums[dst] = nums[src];
//			dst++;
//			src++;
//		}
//	}
//
//	//此时dst的值刚好是数组的新长度
//	return dst;
//}




//void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n)
//{
//	int l1 = m - 1;
//	int l2 = n - 1;
//	int l3 = m + n - 1;
//
//	while (l1 >= 0 && l2 >= 0)
//	{
//		//从后往前比大小
//		if (nums1[l1] > nums2[l2])
//		{
//			nums1[l3--] = nums1[l1--];
//		}
//		else
//		{
//			nums1[l3--] = nums2[l2--];
//		}
//	}
//
//	//要么是l1 < 0，要么是l2 < 0
//	while (l2 >= 0)
//	{
//		nums1[l3--] = nums2[l2--];
//	}
//}



#include "SList.h"

void SListTest01()
{
	//一般不会这样去创建链表，这里只是为了给大家展示链表的打印
	SLTNode* node1 = (SLTNode*)malloc(sizeof(SLTNode));
	node1->data = 1;
	SLTNode* node2 = (SLTNode*)malloc(sizeof(SLTNode));
	node2->data = 2;
	SLTNode* node3 = (SLTNode*)malloc(sizeof(SLTNode));
	node3->data = 3;
	SLTNode* node4 = (SLTNode*)malloc(sizeof(SLTNode));
	node4->data = 4;

	node1->next = node2;
	node2->next = node3;
	node3->next = node4;
	node4->next = NULL;

	SLTNode* plist = node1;
	SLTPrint(plist);
}

void SListTest02()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	//SLTPushBack(NULL, 5);

	//SLTPushFront(&plist, 5);
	//SLTPrint(plist);
	//SLTPushFront(&plist, 6);
	//SLTPrint(plist);
	//SLTPushFront(&plist, 7);
	//SLTPrint(plist);

	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
}

void SListTest03()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	//头删
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);

	//SLTNode* FindRet = SLTFind(&plist, 3);

	if (FindRet)
	{
		printf("找到了！\n");
	}
	else
	{
		printf("未找到！\n");
	}

	SLTInsert(&plist, FindRet, 100);
	SLTPrint(plist);

	SLTInsertAfter(FindRet, 100);
	SLTPrint(plist);

	删除指定位置的节点
	//SLTErase(&plist, FindRet);
	//SLTPrint(plist);

	SListDesTroy(&plist);
}


int main()
{
	//SListTest01();
	//SListTest02();
	SListTest03();

	return 0;
}

3. 链表的分类

链表的结构非常多样，以下情况组合起来就有8种（2 x 2 x 2）链表结构：
链表的分类
链表说明：
链表说明
注：

  1. 之前代码里写的 SList 意思是 single linked list --> 单链表（不带头单向不循环链表）
  2. 刚才在单链表中提到的“头节点”指的是第一个有效的节点；“带头”链表里的“头”指的是无效的节点
  3. “带头”中的“头”：放哨的；头节点：哨兵位（不保存任何有效的数据）

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：单链表和双向带头循环链表。

  1. 无头单向非循环链表：结构简单，⼀般不会单独用来存数据，实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等；另外这种结构在笔试面试中出现很多。
  2. 带头双向循环链表：结构最复杂，⼀般用在单独存储数据，实际中使用的链表数据结构，都是带头双向循环链表；另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。

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

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

相关文章

【Linux】初识Linux操作系统

【Linux】初识Linux操作系统

目录 一、shell 二、Linux命令的分类 三、Linux命令的格式 四、编辑Linux命令行的辅助操作 五、查看命令使用说明的方法 六、基础命令 一、shell ●Linux系统中运行的一个特殊程序&#xff0c;位于用户与内核之间 ●作用&#xff1a;作为“翻译官”&#xff0c;接收用户…
阅读更多...
基于Java+SpringBoot+Vue网络相册设计与实现（源码+文档+部署+讲解）

基于Java+SpringBoot+Vue网络相册设计与实现（源码+文档+部署+讲解）

一.系统概述 网络相册设计与实现的目的是让使用者可以更方便的将人、设备和场景更立体的连接在一起。能让用户以更科幻的方式使用产品&#xff0c;体验高科技时代带给人们的方便&#xff0c;同时也能让用户体会到与以往常规产品不同的体验风格。 与安卓&#xff0c;iOS相比较起…
阅读更多...
C++ 类和对象（中篇）

C++ 类和对象（中篇）

类的6个默认成员函数 如果一个类中什么成员都没有&#xff0c;简称为空类。空类中什么都没有吗&#xff1f;并不是的&#xff0c;任何一个类在我们不写的情 况下&#xff0c;都会自动生成下面6个默认成员函数。 构造函数&#xff1a; 定义&#xff1a;构造函数是一个特殊的成员…
阅读更多...
【PHP系统学习】——Laravel框架数据库的连接以及数据库的增删改查的详细教程

【PHP系统学习】——Laravel框架数据库的连接以及数据库的增删改查的详细教程

&#x1f468;‍&#x1f4bb;个人主页&#xff1a;开发者-曼亿点 &#x1f468;‍&#x1f4bb; hallo 欢迎 点赞&#x1f44d; 收藏⭐ 留言&#x1f4dd; 加关注✅! &#x1f468;‍&#x1f4bb; 本文由 曼亿点 原创 &#x1f468;‍&#x1f4bb; 收录于专栏&#xff1a…
阅读更多...
【招贤纳士】长期有效

【招贤纳士】长期有效

【招贤纳士】长期有效&#xff0c;有意者联系 一、SLAM算法工程师工作内容&#xff1a;任职资格&#xff1a; 二、规划算法工程师工作内容&#xff1a;任职资格&#xff1a; 工作地点&#xff1a;深圳南山 公司行业&#xff1a;家用扫地机器人 待遇从优&#xff0c;有机器人比赛…
阅读更多...
CAD导入GIS平台常见问题大全

CAD导入GIS平台常见问题大全

1.CAD导入图新地球报【坐标超出范围】、【导入失败】 一般是投影不对&#xff0c;多数是中央经线选错了&#xff0c;或者是没注意是否有带号 这种情况&#xff0c;先打开CAD软件&#xff0c;通过id命令看一下数据的坐标&#xff0c;如下图 看到坐标是这样式的&#xff0c;X达…
阅读更多...
达梦数据库审计相关参数

达梦数据库审计相关参数

达梦数据库审计相关参数 基础环境 操作系统&#xff1a;Red Hat Enterprise Linux Server release 7.9 (Maipo) 数据库版本&#xff1a;DM Database Server 64 V8 架构&#xff1a;单实例1 查看审计相关的参数 查看AUD相关的参数。 1.1 查看dm.ini配置文件。 在dm.ini配置文…
阅读更多...
gurobi不同版本切换

gurobi不同版本切换

每年年底&#xff0c;gurobi都会推出新版本。新版本是大的迭代更新&#xff0c;求解问题的效率和精度都会提升。官方人员一般会建议我们安装最新的版本&#xff0c;此外&#xff0c;写论文审稿专家也会建议我们使用较新的版本。 从我们现装的版本切换到新版本。我以往的做法是…
阅读更多...
【CVE-2023-38831】进行钓鱼攻击的研究

【CVE-2023-38831】进行钓鱼攻击的研究

本文仅仅是对相关漏洞利用的学习记录&#xff0c;请各位合法合规食用&#xff01; WinRAR是一款文件压缩器,该产品支持RAR、ZIP等格式文件的压缩和解压等。WinRAR在处理压缩包内同名的文件与文件夹时代码执行漏洞,攻击者构建由恶意文件与非恶意文件构成的特制压缩包文件,诱导受…
阅读更多...
【负载均衡——一致性哈希算法】

【负载均衡——一致性哈希算法】

1.一致性哈希是什么 一致性哈希算法就很好地解决了分布式系统在扩容或者缩容时&#xff0c;发生过多的数据迁移的问题。 一致哈希算法也用了取模运算&#xff0c;但与哈希算法不同的是&#xff0c;哈希算法是对节点的数量进行取模运算&#xff0c;而一致哈希算法是对 2^32 进…
阅读更多...
吴恩达机器学习理论基础—决策树模型

吴恩达机器学习理论基础—决策树模型

吴恩达机器学习理论基础—决策树模型 决策树模型&#xff08;Decision Trees&#xff09; 采用猫狗分类的数据集&#xff0c;同时拥有三个基本的特征&#xff08;输入&#xff09;作为模型建立时使用的数据集。 将构造出来的决策树&#xff0c;分为了决策结点和叶子节点&#…
阅读更多...
【C++入门】内联函数、auto与基于范围的for循环

【C++入门】内联函数、auto与基于范围的for循环

&#x1f49e;&#x1f49e; 前言 hello hello~ &#xff0c;这里是大耳朵土土垚~&#x1f496;&#x1f496; &#xff0c;欢迎大家点赞&#x1f973;&#x1f973;关注&#x1f4a5;&#x1f4a5;收藏&#x1f339;&#x1f339;&#x1f339; &#x1f4a5;个人主页&#x…
阅读更多...
2024-04-08

2024-04-08

作业要求&#xff1a; 1> 思维导图 2>使用手动连接&#xff0c;将登录框中的取消按钮使用qt4版本的连接到自定义的槽函数中&#xff0c;在自定义的槽函数中调用关闭函数 将登录按钮使用qt4版本的连接到自定义的槽函数中&#xff0c;在槽函数中判断ui界面上输入的账号是否…
阅读更多...
【日常记录】【JS】一道解构面试题

【日常记录】【JS】一道解构面试题

文章目录 1、描述2、分析与实现3、参考链接 1、描述 让这一段代码可以执行&#xff0c;并且正确输出 let [name, age] {name: 呆呆狗,age: 20}console.log(name, age);2、分析与实现 在浏览器上执行这段代码会报错 翻译以下&#xff1a;不是可迭代对象 可迭代对象&#xff08;…
阅读更多...
Go——面向对象

Go——面向对象

一. 匿名字段 go支持只提供类型而不写字段名的方式&#xff0c;也就是匿名字段&#xff0c;也称为嵌入字段。 同名字段的情况 所以自定义类型和内置类型都可以作为匿名字段使用 指针类型匿名字段 二.接口 接口定义了一个对象的行为规范&#xff0c;但是定义规范不实现&#xff…
阅读更多...
MT3022 召唤神龙

MT3022 召唤神龙

思路&#xff1a;二分答案 。check():检查组p套卡是否成立&#xff0c;即检查r卡是否足够组成p套卡。 &#xff08;易错点&#xff1a;check的思路&#xff0c;开long long&#xff09; #include <bits/stdc.h> using namespace std; long long int n, m; long long int…
阅读更多...
JavaScript逆向爬取实战——使用Python实现列表页内容爬取

JavaScript逆向爬取实战——使用Python实现列表页内容爬取

JavaScript逆向爬取—使用Python实现列表页内容爬取 1. 案例介绍 案例网址&#xff1a;https://spa6.scrape.center/&#xff0c; 如图所示&#xff1a; 点击任意一步电影&#xff0c;观察一下URL的变化&#xff0c;如图所示&#xff1a; 看到详情页URL包含了一个长字符串&am…
阅读更多...
力扣HOT100 - 189. 轮转数组

力扣HOT100 - 189. 轮转数组

解题思路&#xff1a; 三次反转。 先反转一次&#xff0c;再根据 k 拆分成两部分各反转一次。 class Solution {public void rotate(int[] nums, int k) {k % nums.length;reverse(nums, 0, nums.length - 1);reverse(nums, 0, k - 1);reverse(nums, k, nums.length - 1);}pu…
阅读更多...
使用Docker中构建Java jar包，并且实现开启自启

使用Docker中构建Java jar包，并且实现开启自启

文章目录 1.创建Dockerfile2.构建Docker镜像3.运行Docker容器4.后台运行并且可以开机自启4.1 在后台运行Docker容器4.2 设置开机自启动容器4.3 在Docker守护程序启动时自动启动容器 Docker中构建Java JAR包 要在Docker容器中构建Java应用程序的JAR包&#xff0c;你可以遵循以下…
阅读更多...
RISC-V GNU Toolchain 工具链安装问题解决（stdio.h 问题解决，pk fence.i 问题解决）

RISC-V GNU Toolchain 工具链安装问题解决（stdio.h 问题解决，pk fence.i 问题解决）

我的安装过程主要参照 riscv-collab/riscv-gnu-toolchain 的官方 Readme 和这位佬的博客&#xff1a;RSIC-V工具链介绍及其安装教程 - 风正豪 &#xff08;大佬的博客写的非常详细&#xff0c;唯一不足就是 sudo make linux -jxx 是全部小写。&#xff09; 工具链前前后后我装了…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023