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

news2025/4/13 20:20:00

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

在这里插入图片描述

文章目录

    • 🍌前言
    • 💻无头单向非循环链表
      • 🔍1.链表的定义
      • ⭐指针类型
      • 🔍2.链表的遍历（打印）
      • ⭐代码理解
      • 🔍3.链表的头插
      • ⭐误区（为什么传指针改变不了实参）
      • 🔍4.链表的尾插
      • ⭐误区1.找尾结点错误
      • ⭐误区2.为什么不用一级指针
      • 🔍5.链表的尾删
      • 🔍6.链表的头删
      • 🔍7.链表的查找
      • ⭐assert断言
      • 🔍8.链表的任意位置的插入
      • 🔍9.链表的任意位置之后的插入
      • 🔍10.链表的任意位置的删除(pos位置）
      • 🔍11.链表的删除(pos位置后的结点）
      • 🔍12.链表的销毁
      • 👻SList.h代码
      • 👻SList.c代码
      • 👻test.c代码
      • 🧋代码效果展示

🍌前言

友友们，上期给大家介绍完顺序表功能实现之后，我们知道了它的一个绝对优势就是下标的随机访问，但是顺序表也有以下几个不优的特点：
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;
}

🧋代码效果展示

在这里插入图片描述

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

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

相关文章

SSM（Spring、SpringMVC、MyBatis）整合、配置

SSM（Spring、SpringMVC、MyBatis）整合、配置

SpringMVC是一个表述层(前台的页面和后台的servlet)框架&#xff0c;处理浏览器发送到服务器的请求&#xff0c;并且将一些数据响应到浏览器 MyBatis是一个持久层框架&#xff0c;帮助我们连接数据库&#xff0c;访问数据库&#xff0c;操作数据库中的数据 Spring是一个整合型框…
阅读更多...
毕业论文相关

毕业论文相关

毕业论文参考文献和Word保存 一、Word中出现[7-9]多个文献的引用 在正文中选中参考文献角标&#xff0c;右击选择“切换域代码”&#xff0c;参考文献角标[7][8][9]变为{ REF _Ref98345319 \r \h * MERGEFORMAT }{ REF _Ref98345321 \r \h * MERGEFORMAT }{ REF _Ref99390603…
阅读更多...
AQS独占锁之ReentrantLock源码调试（JDK8）

AQS独占锁之ReentrantLock源码调试（JDK8）

前言&#xff1a; 为什么需要学习ReentrantLock? 目前项目开发中使用到的几乎都是分布式锁&#xff0c;平时可能很少用到java自带的锁&#xff1b; 但实际在我们java的源码中&#xff0c;随处可见需要使用锁来保证线程安全&#xff0c;所以还是有必要学习下ReentrantLock。 1…
阅读更多...
7.分区表和分桶表

7.分区表和分桶表

1.创建分区表 create table dept_partition(deptno int,dname string,loc int ) partitioned by (dt string) // 分区字段(date) row format delimited fields terminated by \t; 2.增删改查操作 2.1 插入数据 1&#xff09;导入本地数据 -- 创建一个名字为dt2022-06-14的…
阅读更多...
R语言 | 输入与输出

R语言 | 输入与输出

目录 一、认识文件夹 1.1 getwd()函数 1.2 setwd()函数 1.3 file.path()函数 1.4 dir()函数 1.5 list.files()函数 1.6 file.exists()函数 1.7 file.rename()函数 1.8 file.create()函数 1.9 file.copy()函数 ​1.10 file.remove()函数 二、数据输出&#xff1a;ca…
阅读更多...
单片机c51中断 — 中断扫描法行列式键盘

单片机c51中断 — 中断扫描法行列式键盘

项目文件 文件 关于项目的内容知识点可以见专栏单片机原理及应用 的第五章&#xff0c;中断 在第4章中已介绍过行列式键盘的工作原理&#xff0c;并编写了相应的键盘扫描程序。但应注意的是&#xff0c;在单片机应用系统中&#xff0c;键盘扫描只是 CPU 工作的内容之一。CPU …
阅读更多...
一文理清 TiDB 与 MySQL 中的常用字符集及排序规则

一文理清 TiDB 与 MySQL 中的常用字符集及排序规则

1. 字符集&#xff08;character set&#xff09; 1.1. 字符集与编码规则 字符集&#xff08;character set&#xff09;即为众多字符的集合。字符集为每个字符分配一个唯一的 ID&#xff0c;称为 “Code Point&#xff08;码点&#xff09;”。编码规则是将 Code Point 转换…
阅读更多...
商户查询的缓存——缓存击穿问题

商户查询的缓存——缓存击穿问题

缓存击穿问题也叫热点key问题&#xff0c;就是一个被高并发访问并且缓存重建业务比较复杂的key突然失效了&#xff0c;无数的请求访问会在瞬间给数据库带来巨大的冲击 常见的解决方案有两种&#xff1a; 互斥锁&#xff08;高并发时性能较差&#xff09; 逻辑过期 基于互斥锁方…
阅读更多...
ASN.1-PKCS10-x509

ASN.1-PKCS10-x509

在国际标准ITU-T X.690 《Information technology – ASN.1 encoding rules: Specification of Basic Encoding Rules (BER), Canonical Encoding Rules (CER) and Distinguished Encoding Rules (DER)》中定义了ASN.1编码规则。对于一般数据类型&#xff08;比如Integer、octe…
阅读更多...
【软件工程】自动化测试保证卓越软件工程能力（2）

【软件工程】自动化测试保证卓越软件工程能力（2）

本次内容我们抽象一个待测试的目标软件产品&#xff0c;产品是基于web开发的。 自动化平台不是独立存在的&#xff0c;必然有一个目标待测试产品&#xff0c;用自动化测试来反映产品功能是否还是好的。 产品抽象v1 第一个版本&#xff0c;使用者&#xff08;USER&#xff09;发…
阅读更多...
配置本地Angular环境并使用VsCode调试Angular前端项目

配置本地Angular环境并使用VsCode调试Angular前端项目

配置本地Angular环境并使用VsCode调试Angular前端项目 配置本地Angular环境部署Node.Js本地环境配置一下环境变量 使用vscode调试Angular安装vscode 配置本地Angular环境 部署Node.Js本地环境 1 从官网下载node.js, 本文为(v16.13.0) 下载地址: https://nodejs.org/dist/v16.…
阅读更多...
windows server 2016报错无法打开所需文件install.wim

windows server 2016报错无法打开所需文件install.wim

报错的前提条件： 1.下载原版镜像后，使用UltraISO制作U盘系统盘。 2.正常安装系统，到“安装程序正在启动界面”时弹出错误窗口，报错“Windows无法打开所需的文件 E:\Source\install.win。请确保安装所需的所有文件可用，并重新启动安装。错误代码：0x80070026”。 问题原因…
阅读更多...
【MySQL学习】MySQL表的复合查询

【MySQL学习】MySQL表的复合查询

文章目录 前言一、案例准备二、基本查询三、多表查询四、子查询4.1 单行子查询4.2 多行子查询4.3 多列子查询4.4 FROM子句中的子查询4.5 合并查询4.5.1 UNION4.5.2 UNION ALL 五、自连接六、内外连接6.1 内连接6.2 外连接6.2.1 左外连接6.2.2 右外连接 前言 对MySQL表的基本查…
阅读更多...
大数据系列——Flink理论

大数据系列——Flink理论

概述 Flink是一个对有界和无界数据流进行有状态计算的分布式处理引擎和框架&#xff0c;既可以处理有界的批量数据集&#xff0c;也可以处理无界的实时流数据&#xff0c;为批处理和流处理提供了统一编程模型&#xff0c;其代码主要由 Java 实现&#xff0c;部分代码由 Scala实…
阅读更多...
Java——Java选择题复习（1）（Java基础，进程，多线程，操作系统）

Java——Java选择题复习（1）（Java基础，进程，多线程，操作系统）

1. 下面关于程序编译说法正确的是&#xff08;&#xff09; A. java语言是编译型语言&#xff0c;会把java程序编译成二进制机器指令直接运行 B. java编译出来的目标文件与具体操作系统有关 C. java在运行时才进行翻译指令 D. java编译出来的目标文件&#xff0c;可以运行在任意…
阅读更多...
房地产中介迎来重磅文件，但核心目标仍是专业化规范化发展

房地产中介迎来重磅文件，但核心目标仍是专业化规范化发展

5月8日下午&#xff0c;住房和城乡建设部、市场监管总局联合刊登重磅文件《关于规范房地产经纪服务的意见》&#xff08;以下简称《意见》&#xff09;&#xff0c;因其涉及对经纪服务收费等具体问题的指导&#xff0c;文件引发市场重点关注。 不过&#xff0c;在系统性梳理文…
阅读更多...
Redisson cannot use an unresolved DNS server address问题解决

Redisson cannot use an unresolved DNS server address问题解决

概述 本文记录Mac IDEA开发&#xff0c;公司 远程办公时遇到的两个问题&#xff0c;记录一下。 问题 cannot use an unresolved DNS server address: [fe80::1%en0]:53 在家里&#xff0c;连上公司的VPN后&#xff0c;即可打开公司内网&#xff0c;远程办公。一切正常。某…
阅读更多...
JVM学习（七）：运行时数据区（精讲）

JVM学习（七）：运行时数据区（精讲）

目录 一、运行时数据区概述 1.1 概述 1.2 运行时数据区中的GC和OOM 二、程序计数器&#xff08;PC寄存器&#xff0c;Program Counter Register&#xff09; 2.1 介绍 2.2 作用 2.3 特点 2.4 使用案例 2.5 常见面试题 三、虚拟机栈&#xff08;Java Virtual Machi…
阅读更多...
前端008_类别模块_新增功能

前端008_类别模块_新增功能

类别模块_新增功能 1、需求分析2、新增窗口实现3、列表引用新增组件4、关闭弹出窗口5、校验表单数据6、提交表单数据6.1、Mock 添加新增模拟接口6.2、Api 调用接口6.3、测试新增功能1、需求分析 点击 新增 按钮后，对话框形式弹出新增窗口输入分类信息后，点击 确定 提交表单数…
阅读更多...
IDEA小技巧-Git的回滚强推代码找回

IDEA小技巧-Git的回滚强推代码找回

标题IDEA小技巧-Git的回滚&&强推&&代码找回 本地未Commit 新增文件 delete 变更文件 rollback 第一种方式 第二种方式 切换默认变更列表 Commit未push undo commit 仅适用于最后一次的提交进行回滚 drop commit 回滚 revert commit revert commi…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023