1. Toy模板网首页
  2. > Toy博客

一篇文章带你重新回溯单链表的所有

8月前 作者：阿博历练记 分类：Toy博客 阅读(48) 违法举报

这篇具有很好参考价值的文章主要介绍了一篇文章带你重新回溯单链表的所有。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

🍉博客主页：阿博历练记
📗文章专栏：数据结构与算法
🚚代码仓库：阿博编程日记
🌹欢迎关注：欢迎友友们订阅收藏+关注哦

一篇文章带你重新回溯单链表的所有

🍌前言

友友们，上期给大家介绍完顺序表功能实现之后，我们知道了它的一个绝对优势就是下标的随机访问，但是顺序表也有以下几个不优的特点：
1.中间/头部的插入删除，时间复杂度为O(N)
一篇文章带你重新回溯单链表的所有
2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
一篇文章带你重新回溯单链表的所有
3.增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
顺序表的一切根源就是：需要一块连续的物理空间。这时候我们就会想有没有什么好的解决方案可以做到空间可以按需申请释放，插入删除数据的时候时间复杂度能够变成O(1),这时候就要引入链表了，链表的空间是不连续的.
1.带头或者不带头
一篇文章带你重新回溯单链表的所有
2.循环或者非循环
一篇文章带你重新回溯单链表的所有
虽然有这么多的链表的结构，但是我们实际中最常用还是无头单向非循环链表.无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多.

💻无头单向非循环链表

🔍1.链表的定义

typedef  int  SLTDataType;
typedef struct  SListNode
{
	SLTDataType  data;
	struct SListNode* next;
}SLTNode;

一篇文章带你重新回溯单链表的所有

⭐指针类型

友友们注意了，因为我们的结点是用结构体定义的，所以结点是一个结构体类型的变量，而这个next指针是下一个结点的地址，它指向了下一个结点，所以它的类型要和我们结点类型保持一致.

🔍2.链表的遍历（打印）

void  SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur!=NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

⭐代码理解

1.逻辑结构
一篇文章带你重新回溯单链表的所有
2.物理结构
一篇文章带你重新回溯单链表的所有

🔍3.链表的头插

SLTNode* BuyLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return  NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	return  newnode;
}
void  SLPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);            //链表为空，pphead也不能为空，因为它是头指针plist的地址，如果它为空，就会出现对空指针的解引用，所以我们需要断言一下
	//assert(*pphead);        //不能断言，链表即使为空，也需要插入
	//SLTNode  node;        这是一个局部的结点，在栈区上存放着，出了作用域就销毁了
	SLTNode* newnode = BuyLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

⭐误区（为什么传指针改变不了实参）

❌错误案例

SLTNode* BuyLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return  NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	return  newnode;
}
void  SLPushFront(SLTNode* phead, SLTDataType x)
{
	SLTNode* newnode = BuyLTNode(x);
	newnode->next = phead;
	phead = newnode;
}
void  TestSList1()
{
	SLTNode* plist = NULL;
	SLPushFront(plist, 1);
	SLPushFront(plist, 2);
	SLPushFront(plist, 3);
	SLPushFront(plist, 4);
	SLTPrint(plist);
}

一篇文章带你重新回溯单链表的所有
这里阿博再给友友们举例解释一下
❌错误案例

void swap(int* p1, int* p2)
{
	int *temp = p1;
	p1 = p2;   
	p2 = temp;
}
int  main()
{
	int a = 0;
    int b = 1;
	int* px = &a, * py = &b;
	swap(px, py);
	return  0;
}

一篇文章带你重新回溯单链表的所有

友友们注意，这里我们p1和p2的改变并不能影响px和py，因为我们传的是px和py，用p1和p2分别接收，这本质上就是整形指针变量的赋值，形参只是实参的一份临时拷贝，形参的改变并不会影响实参.我们如果要想改变，就必须传地址，然后解引用改变它，要改变int，就要传int的地址，要改变int*,就要传int*的地址.我们要改变谁，就要传谁的地址.

✔正确案例

void swap(int** pp1, int** pp2)
{
	int *temp = *pp1;
	*pp1 = *pp2;   
	*pp2 = temp;
}
int  main()
{
	int a = 0;
    int b = 1;
	int* px = &a, * py = &b;
	swap(&px, &py);
	return  0;
}

所以友友们如果我们要改变plist，就要传plist的地址.

🔍4.链表的尾插

void  SLPushBack(SLTNode** pphead, SLTDataType x)
{
//assert(*pphead);    //链表为空，可以尾插
	assert(pphead);   //链表为空，pphead也不能为空，因为它是头指针plist的地址，如果它为空，就会出现对空指针的解引用，所以我们需要断言一下
	SLTNode* newnode = BuyLTNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;      //改变结构的指针plist
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{ 
			tail = tail->next;
		}
		tail->next = newnode;    //改变结构体的尾结点
	}
}

友友们，这里我们尾插就需要找到尾结点.

⭐误区1.找尾结点错误

❌错误案例

void  SLPushBack(SLTNode* phead, SLTDataType x)
{
	SLTNode* tail = phead;
	while (tail != NULL)
	{
		tail = tail->next;              
	}
	SLTNode* newnode = BuyTLNode(x);    
	tail = newnode;
}

一篇文章带你重新回溯单链表的所有

友友们，让上一个结点存放下一个结点的地址才是我们尾插的实质，所以我们要找尾就要修改一下循环条件，因为尾结点的next指针为空，所以我们把循环条件改为tail->next!=NULL,这样tail就指向了尾结点.⛳友友们这里还有一个关键点就是tail和newnode都是局部变量，出完作用域就销毁了，但是结点的next指针是不会销毁的，因为它属于结点，而我们结点是malloc开辟出来的，在堆区上存放，程序运行结束或者free掉才会销毁.

⭐误区2.为什么不用一级指针

案例1
一篇文章带你重新回溯单链表的所有
一篇文章带你重新回溯单链表的所有
这里友友们可能有疑问，这里用一级指针不是也可以尾插成功吗，那我们为什么还用二级指针呢，我们这里再换一种情况就会有一种意想不到的结果.🙉🙉🙉

案例二
一篇文章带你重新回溯单链表的所有
友友们这里我们都会迷惑，为什么这里一级指针就不行了呢，下面和阿博一起来探索它.
一篇文章带你重新回溯单链表的所有
一篇文章带你重新回溯单链表的所有
所以友友们这里如果我们要想改变plist，就要传plist的地址.友友们注意如果plist为空时，我们要改变plist，就要传plist的地址，就要用二级指针，但是当plist不为空时，我们尾插其实就是让tail->next=BUYLTNode(x),我们此时改变的是tail的next指针，它是结构体里面的内容，这时候我们用结构体指针就可以改变，就是一级指针就可以尾插.要改变谁，我们就要传谁的地址.

1.*pphead=newnode 改变的是结构的指针plist，所以用二级指针.
2.tail->next=newnode 改变的是结构体的尾结点，用一级指针就可以.

⛳友友们注意，头插和尾插是不一样的，头插每一次都需要传结构体指针plist地址，因为头插的时候，需要赋值（*pphead=newnode），*pphead就是就是plist，就相当于我们每一次都要改变plist，所以我们每一次都需要传plist的地址，而尾插只需要第一次传就可以了，因为第一次改变的是plist（结构体的地址），其它都是改变的是tail->next（结构体的尾结点）.

🔍5.链表的尾删

void  SLPopBack(SLTNode** pphead)
{
	//没有结点
	//一个结点
	//多个结点
	assert(pphead) //链表为空，pphead也不能为空，因为它是头指针plist的地址，如果它为空，就会出现对空指针的解引用，所以我们需要断言一下
	assert(*pphead);   //声明一下如果链表为空就不能尾删了
	if ((*pphead)->next== NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* prev = NULL;
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);     //指向被释放的空间，野指针问题
		//tail = NULL;
		prev->next = NULL;
	}
}

一篇文章带你重新回溯单链表的所有

🔍6.链表的头删

友友们，这里我们头删的时候，有两种方法，第一种就是保留旧头结点的地址，然后让新头结点往后走，释放旧的头结点第二种就是保留头结点下一结点的地址，然后释放头结点，把头结点下一结点的地址给新的头结点.
1.保留头结点下一结点的地址

void  SLPopFront(SLTNode** pphead)
{
	assert(*pphead);   //链表为空，不能头删
	assert(pphead);     //链表为空，pphead也不能为空，因为它是头指针plist的地址，如果它为空，就会出现对空指针的解引用，所以我们需要断言一下
	if ((*pphead)->next == NULL)      //一个结点
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* del = (*pphead)->next;
		free(*pphead);
		*pphead = del;
		/**pphead = (*pphead)->next;
		free(del);*/
	}
}

2.保留头结点的地址

void  SLPopFront(SLTNode** pphead)
{
	assert(*pphead);   //链表为空，不能头删
	assert(pphead);     //链表为空，pphead也不能为空，因为它是头指针plist的地址，如果它为空，就会出现对空指针的解引用，所以我们需要断言一下
	if ((*pphead)->next == NULL)      //一个结点
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* del = *pphead;
		*pphead = (*pphead)->next;
		free(del);
	}
}

🔍7.链表的查找

SLTNode* STFind(SLTNode* phead, SLTDataType  x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return  cur;
		}
		cur = cur->next;
	}
	return  NULL;
}

友友们注意，这里while循环里面不能是cur->next，因为这样的话虽然cur指到尾结点了，但是while循环没进去，if语句没有执行，所以尾结点的data就没有和x比较，就相当于少遍历一个结点.

⭐assert断言

友友们并不是所有的指针都需要断言，我们要判断，比如说：链表的查找，链表的打印，这里我们就不需要再去进行 assert(phead)，因为链表为空，循环就没有进去，只不过找不到返回空，打印为空.比如链表的头插，我们就需要断言（pphead）,因为pphead是plist的地址，如果它为空，newnode->next =*pphead;这一句就会出现对空指针的解引用，所以我们需要断言一下，但是assert(*pphead)这个就不需要断言了，因为(*pphead)是plist，它为空就相当于plist为空，链表为空不影响我们头插，所以这里就不需要断言.但是头删和尾删的时候我们就需要进行断言一下(*pphead)，因为它就是plist，如果链表为空，就不要再头删或者尾删了.

🔍8.链表的任意位置的插入

void  SLInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	if (*pphead == pos)
	{
		SLPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuyLTNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

友友们，我们假设这个位置是pos，我们要在pos位置上插入数据，pos之后的数据就要往后挪动，就相当于我们在pos之前插入数据.
一篇文章带你重新回溯单链表的所有
这里我们的二级指针就是为头插那个地方准备的，因为如果不是头插的话，我们改变的都是结构体的next指针，它们都属于结构体，我们只需要一个结构体指针就可以了，就不需要用二级指针了.

🔍9.链表的任意位置之后的插入

void  SLInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuyLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode; 
}

友友们注意这里newnode->next和pos->next先后顺序不能弄反，如果我们先改变pds->next的话，这样newnode->next=newnode，它就自己指向自己了，就成了一个环.

🔍10.链表的任意位置的删除(pos位置）

void  SLErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SLPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
	}
}

一篇文章带你重新回溯单链表的所有

🔍11.链表的删除(pos位置后的结点）

void  SLEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);   //防止它是最后一个，这样它后面就没有节点了
	SLTNode* next = pos->next;
	pos->next = next->next;
	free(next);
}

友友们这里要注意我们要提前保存好我们我们要删除位置之后的结点，否则我们改变pos->next之后，就找不到它起初的位置了，还有一定要注意如果是尾结点，就不能再用这个函数了，因为尾结点的下一结点为空，我们就不需要删了，所以这里需要断言一下.

🔍12.链表的销毁

void   SLDestory(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

友友们注意这里我们先要保存下一结点，否则我们free掉头结点后我们就找不到下一结点了.

👻SList.h代码

#pragma once
#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  SLPushFront(SLTNode** phead,SLTDataType x);
void  SLPushBack(SLTNode** pphead, SLTDataType x);
void  SLPopFront(SLTNode** pphead);
void  SLPopBack(SLTNode** pphead);
//单链表查找
SLTNode* STFind(SLTNode* phead, SLTDataType  x);
//在pos之前插入
void  SLInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//在pos之后插入
void   SLInsertAfter(SLTNode* pos, SLTDataType  x);
//删除pos位置的值
void  SLErase(SLTNode** pphead, SLTNode*pos);
//删除pos位置后面的值
void   SLEraseAfter(SLTNode* pos);
void   SLDestory(SLTNode** pphead);

👻SList.c代码

#define  _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"
void  SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur!=NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}
SLTNode* BuyLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return  NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	return  newnode;
}
void  SLPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);            //链表为空，pphead也不能为空，因为它是头指针plist的地址，如果它为空，就会出现对空指针的解引用，所以我们需要断言一下
	//assert(*pphead);        //不能断言，链表即使为空，也需要插入
	//SLTNode  node;        这是一个局部的结点，在栈区上存放着，出了作用域就销毁了
	SLTNode* newnode = BuyLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}
void  SLPushBack(SLTNode** pphead, SLTDataType x)
{
	//SLTNode* tail = phead;
	//while (tail->next != NULL)
	//{
	//	tail = tail->next;              
	//}
	//SLTNode* newnode = BuyLTNode(x);       //这里并没有把链表链接起来，因为tail和newnode都是局部变量，出了作用域就销毁了，而且内存存在泄露，链表链接的实质是尾部的next指针指向下个结点的地址
	//tail->next = newnode;
	//1.空链表
	//2.非空链表
	//assert(*pphead);    //链表为空，可以尾插
	assert(pphead);   //链表为空，pphead也不能为空，因为它是头指针plist的地址，如果它为空，就会出现对空指针的解引用，所以我们需要断言一下
	SLTNode* newnode = BuyLTNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;      //改变结构的指针plist
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{ 
			tail = tail->next;
		}
		tail->next = newnode;    //改变结构体的尾结点
	}
}
void  SLPopBack(SLTNode** pphead)
{
	//没有结点
	//一个结点
	//多个结点
	/*if (*pphead == NULL)
	{
		return;
	}*/
	assert(pphead);
	assert(*pphead);
	if ((*pphead)->next== NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* prev = NULL;
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);     //指向被释放的空间，野指针问题
		//tail = NULL;
		prev->next = NULL;
	}
}
void  SLPopFront(SLTNode** pphead)
{
	assert(*pphead);   //链表为空，不能头删
	assert(pphead);     //链表为空，pphead也不能为空，因为它是头指针plist的地址，如果它为空，就会出现对空指针的解引用，所以我们需要断言一下
	if ((*pphead)->next == NULL)      //一个结点
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* del = *pphead;
		*pphead = (*pphead)->next;
		free(del);
	}
}
SLTNode* STFind(SLTNode* phead, SLTDataType  x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return  cur;
		}
		cur = cur->next;
	}
	return  NULL;
}
void  SLInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	if (*pphead == pos)
	{
		SLPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuyLTNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}
void  SLInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuyLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode; 
}
void  SLErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SLPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
	}
}
void  SLEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);   //防止它是最后一个，这样它后面就没有节点了
	SLTNode* next = pos->next;
	pos->next = next->next;
	free(next);
}
void   SLDestory(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

👻test.c代码

#define  _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"
void  TestSList1()
{
	SLTNode* plist = NULL;
	SLPushFront(&plist, 1);
	SLPushFront(&plist, 2);
	SLPushFront(&plist, 3);
	SLPushFront(&plist, 4);
	SLPopFront(&plist);

	SLTPrint(plist);
	SLPushBack(&plist, 5);

	SLTPrint(plist);

}
void  TestSList2()
{
	SLTNode* plist = NULL;
	SLPushBack(&plist, 1);
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 4);

	SLTPrint(plist);
	SLTNode* pos = STFind(plist, 3);
	if (pos)
	{
		SLInsert(&plist, pos, 30);
	}
	SLTPrint(plist);
	pos = STFind(plist, 2);
	SLInsertAfter(pos, 20);
	pos = STFind(plist, 2);
	if (pos)
	{
		SLErase(&plist, pos);
	}
	SLTPrint(plist);
	SLDestory(&plist);
}
int  main()
{
	TestSList1();
	TestSList2();
	return  0;
}

🧋代码效果展示

一篇文章带你重新回溯单链表的所有文章来源地址https://www.toymoban.com/news/detail-449558.html

到了这里，关于一篇文章带你重新回溯单链表的所有的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 一篇文章带你实现栈的接口

    一篇文章带你实现栈的接口

    栈（Stacks）是限定在一端插入和删除的线性表。允许插入和删除的一端称为栈顶（Top），另一端称为栈底（Bottom）。栈中的数据元素遵守后进先出（Last In First Out）的原则。因此，栈又称为后进先出（先进后出）线性表。 压栈：栈的插入操作叫做进栈、压栈、入栈，入数据在

    2024年02月13日
    浏览(36)
  • 一篇文章带你走进Java（保姆级）

    一篇文章带你走进Java（保姆级）

    手打不易，希望对各位还在徘徊学什么语言的有帮助！！java不会让你失望！！ Java是一种优秀的程序设计语言，它具有令人赏心悦目的语法和易于理解的语义。 Java还是有一系列计算机软件和规范形成的技术体系，这个技术体系提供了完整的用于软件开发和跨平台部署的支持

    2024年02月15日
    浏览(43)

  • 一篇文章带你了解什么是图灵完备

    图灵完备（Turing-complete）是一个计算机科学中的概念，它指的是一种计算模型能够模拟任何其他计算模型的能力。这意味着，只要一种计算模型是图灵完备的，那么它就能够完成任何可计算的任务。 图灵完备是指一种计算机语言或计算模型具有足够的能力来模拟图灵机的所有

    2024年02月15日
    浏览(33)

  • 一篇文章带你了解什么是JDK

    JDK（Java Development Kit）是Java开发工具包，它提供了开发和运行Java应用程序所需的工具、库和资源。下面是JDK的一些重点介绍： Java编译器（javac）：JDK包含了Java编译器，可以将Java源代码编译为Java字节码。通过编译器，开发人员可以将Java源代码转换为可在JVM上运行的字节码文

    2024年03月19日
    浏览(84)
  • 一篇文章带你快速认识区块链（必看）

    一篇文章带你快速认识区块链（必看）

           区块链技术，这一划时代的分布式账本技术，正在全球范围内掀起一场深度的信任与协作模式变革。区块链如同一部由多方共同维护的公开而又安全的大账本，每一笔交易都被打包成一个区块，通过高级密码学手段确保传输和访问安全，并按照时间顺序串联起来，形

    2024年04月25日
    浏览(47)
  • 一篇文章带你了解SpringBoot目录结构

    一篇文章带你了解SpringBoot目录结构

    前言 SpringBoot是整合Spring技术栈的一站式框架，是简化Spring技术栈的快速开发脚手架，是一个能够快速构建生产级别的Spring应用的工具。SpringBoot是目前流行的微服务框架，倡导“约定优于配置”，简化Spring项目搭建及开发过程。springboot提供了很多核心的功能，比如自动化配置

    2024年03月25日
    浏览(54)
  • 一篇文章带你搞懂前端Cookie

    一篇文章带你搞懂前端Cookie

    浏览器Cookie相信各位点进这篇文章的小伙伴应该不陌生了，它是前端领域中一个非常重要的内容，当然也是面试的一个考点，不知道各位小伙伴是否真正掌握了Cookie呢?当然没有掌握也是没有关系的，可以跟着小编的脚步一起来学习一下前端Cookie，没有熟练掌握的小伙伴看完这

    2024年02月04日
    浏览(34)
  • 一篇文章带你了解-selenium工作原理详解

    一篇文章带你了解-selenium工作原理详解

    前言 Selenium是一个用于Web应用程序自动化测试工具。Selenium测试直接运行在浏览器中，就像真正的用户在操作一样。支持的浏览器包括IE（7, 8, 9, 10, 11），Mozilla Firefox，Safari，Google Chrome，Opera等。 主要功能包括：测试与浏览器的兼容性——测试你的应用程序看是否能够很好得

    2024年02月10日
    浏览(41)
  • 一篇文章带你详细了解axios的封装

    一篇文章带你详细了解axios的封装

    对请求的封装在实际项目中是十分必要的,它可以让我们统一处理 http 请求。比如做一些拦截,处理一些错误等。本篇文章将详细介绍如何封装 axios 请求,具体实现的功能如下 基本配置 配置默认请求地址,超时等 请求拦截 拦截 request 请求,处理一些发送请求之前做的处理,譬如给

    2024年02月07日
    浏览(47)
  • 【C++】一篇文章带你深入了解list

    【C++】一篇文章带你深入了解list

    list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。 list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。 list与forward_list非常相似：最主要的不同在

    2024年04月23日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包