数据结构——单向链表(万字讲解）

news2024/11/24 19:28:38

在这里插入图片描述
单向链表（又名单链表、线性链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过从头部开始，依序往下读取。
在这里插入图片描述

//单链表的打印
void SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
		//cur++;
	}
	printf("NULL\n");
}

这里是单链表的打印函数。

函数将当前节点 cur 指向链表的头节点 phead,接下来遍历整个链表:

如果 cur 不为空,则打印当前节点的数据 cur->data 和箭头 ->
取出 cur 的下一个节点 cur->next,并让 cur 指向下一个节点
重复上述过程直到 cur 为空,打印结束标记 NULL

//单链表新节点的创建
SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

这段代码实现了创建单链表新节点的功能。具体实现是通过调用malloc函数分配内存，用于存储新节点的数据和指针域，然后将数据部分初始化为x，指针域部分初始化为NULL，并返回新节点的指针。

//单链表尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySLTNode(x);

	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		// 找尾
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		tail->next = newnode;
	}
}

这段代码实现了单链表的尾插操作，将新节点插入到链表的末尾。

具体实现是，首先创建一个新节点newnode，通过调用BuySLTNode函数实现。然后判断链表是否为空，如果链表为空，则直接将头指针pphead指向新节点newnode。

如果链表不为空，则需要找到链表的末尾节点，即最后一个节点的next指针为NULL。这里使用一个指针tail，初始指向头结点pphead，然后循环遍历链表，直到找到末尾节点，即tail->next为NULL。然后将新节点newnode插入到末尾节点的后面，即将末尾节点的next指针指向新节点newnode。

需要注意的是，在函数的开头，使用了assert函数判断头指针pphead是否为空，如果为空，则会触发断言错误，程序会停止运行，这是为了确保代码的健壮性。

//单链表头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

这段代码实现了单链表的头插操作，将新节点插入到链表的头部。

具体实现是，首先创建一个新节点newnode，通过调用BuySLTNode函数实现。然后将新节点的next指针指向当前的头结点*pphead，然后将头指针pphead指向新节点newnode。

需要注意的是，在函数的开头，使用了assert函数判断头指针pphead是否为空，如果为空，则会触发断言错误，程序会停止运行，这是为了确保代码的健壮性。

//单链表的尾删
void SLTPopBack(SLTNode** pphead)
{
	// 暴力检查
	assert(pphead);
	assert(*pphead);

	// 温柔的检查
	//if (*pphead == NULL)
	//	return;

	// 1、只有一个节点
	// 2、多个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		// 找尾
		//SLTNode* prev = NULL;
		//SLTNode* tail = *pphead;
		//while (tail->next != NULL)
		//{
		//	prev = tail;
		//	tail = tail->next;
		//}

		//free(tail);
		//tail = NULL;

		//prev->next = NULL;

		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}

		free(tail->next);
		tail->next = NULL;
	}	
}

这段代码实现了单链表的尾删操作，删除链表中的最后一个节点。

具体实现是，首先使用assert函数判断头指针pphead和头结点是否为空，如果为空，则会触发断言错误，程序会停止运行，这是为了确保代码的健壮性。

然后根据链表中节点的个数，分为只有一个节点和多个节点两种情况。如果链表中只有一个节点，则直接将头指针pphead置为空并释放该节点所占用的内存即可。

如果链表中有多个节点，则需要找到倒数第二个节点，即最后一个节点的前一个节点，然后将该节点的next指针置为NULL，释放最后一个节点所占用的内存即可。

需要注意的是，在找到倒数第二个节点时，不能使用prev指针记录前一个节点的位置，因为如果链表中只有两个节点时，prev指针会指向头结点，而不是第一个节点的位置，这样会导致释放内存时出现错误。因此，可以使用一个指针tail，初始指向头结点pphead，然后循环遍历链表，直到tail->next->next为NULL，即tail指向倒数第二个节点的位置，然后释放最后一个节点的内存并将tail的next指针置为NULL。

另外，上面代码中的暴力检查和温柔检查可以用来判断代码的健壮性。暴力检查使用assert函数在程序运行时进行断言判断，如果不满足条件，则会停止程序的运行，并输出错误信息。而温柔检查则是在代码中手动判断，如果不满足条件，则直接返回，不再执行后面的代码。

//单链表的头删
void SLTPopFront(SLTNode** pphead)
{
	// 暴力检查
	assert(pphead);
	assert(*pphead);

	// 温柔的检查
	//if (*pphead == NULL)
	//	return;

	SLTNode* first = *pphead;
	*pphead = first->next;
	free(first);
	first = NULL;
}

这段代码实现了单链表的头删操作，删除链表中的第一个节点。

具体实现是，首先使用assert函数判断头指针pphead和头结点是否为空，如果为空，则会触发断言错误，程序会停止运行，这是为了确保代码的健壮性。

然后将头指针pphead指向第二个节点，然后释放第一个节点所占用的内存即可。

需要注意的是，在删除第一个节点之前，需要使用一个指针first，指向头结点pphead，然后将头指针pphead指向第二个节点，最后释放指针first所指向的内存。这样可以保证在释放第一个节点的内存之后，仍然可以访问第二个节点。

另外，上面代码中的暴力检查和温柔检查可以用来判断代码的健壮性。暴力检查使用assert函数在程序运行时进行断言判断，如果不满足条件，则会停止程序的运行，并输出错误信息。而温柔检查则是在代码中手动判断，如果不满足条件，则直接返回，不再执行后面的代码。

//单链表的查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}

		cur = cur->next;
	}

	return NULL;
}

这段代码实现了在单链表中查找值为x的节点，并返回该节点的指针。

具体实现是，从链表的头结点phead开始遍历整个链表，遍历的过程中，对于每一个节点，判断其数据部分是否等于目标值x，如果等于，则返回该节点的指针。如果遍历完整个链表都没有找到值为x的节点，则返回NULL。

需要注意的是，函数的返回值是一个SLTNode类型的指针，这里使用SLTNode*来表示链表节点的指针类型。

// pos之前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pos);
	assert(pphead);

	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		// 找到pos的前一个位置
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		SLTNode* newnode = BuySLTNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

这段代码实现了在单链表中指定位置pos之前插入一个新节点，该新节点的数据部分为x。

具体实现是，首先使用assert函数判断pos和头指针pphead是否为空，如果为空，则会触发断言错误，程序会停止运行，这是为了确保代码的健壮性。

然后根据pos的位置，分为两种情况进行插入操作。如果pos是链表的头结点，则直接调用SLTPushFront函数在头部插入新节点即可。

如果pos不是链表的头结点，则需要先找到pos的前一个节点，即该节点的next指针指向pos，然后创建一个新节点newnode，将该节点的next指针指向新节点newnode，新节点的next指针指向pos即可。

需要注意的是，在找到pos的前一个节点时，可以使用一个指针prev，初始指向头结点pphead，然后循环遍历链表，直到prev->next指向pos即可。

// pos位置删除
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	//assert(*pphead);

	if (*pphead == pos)
	{
		SLTPopFront(pphead);
	}
	else
	{
		// 找到pos的前一个位置
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

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

这段代码实现了在单链表中删除指定位置pos的节点。

具体实现是，首先使用assert函数判断头指针pphead和指定位置pos是否为空，如果为空，则会触发断言错误，程序会停止运行，这是为了确保代码的健壮性。

然后根据pos的位置，分为两种情况进行删除操作。如果pos是链表的头结点，则直接调用SLTPopFront函数删除其头节点即可。

如果pos不是链表的头结点，则需要先找到pos的前一个节点，即该节点的next指针指向pos，然后将该节点的next指针指向pos的下一个节点，即pos->next，最后释放pos节点所占用的内存即可。

需要注意的是，在找到pos的前一个节点时，可以使用一个指针prev，初始指向头结点pphead，然后循环遍历链表，直到prev->next指向pos即可。此外，释放pos节点的内存后，需要将pos指针置为NULL，以避免出现悬挂指针问题。

// pos后面插入
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

这段代码实现了在单链表中指定位置pos之后插入一个新节点，该新节点的数据部分为x。

具体实现是，首先使用assert函数判断pos是否为空，如果为空，则会触发断言错误，程序会停止运行，这是为了确保代码的健壮性。

然后创建一个新节点newnode，将其next指针指向pos的下一个节点pos->next，然后将pos的next指针指向新节点newnode即可。

需要注意的是，该函数没有传入头指针pphead，因此无法在头部插入新节点。如果需要在头部插入新节点，需要修改函数的参数列表，将头指针pphead作为参数传入，并将pos改为指向头结点。

// pos位置后面删除
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);

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

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

这段代码实现了在单链表中删除指定位置pos后面的节点。

具体实现是，首先使用assert函数判断指定位置pos和其后继节点是否为空，如果为空，则会触发断言错误，程序会停止运行，这是为了确保代码的健壮性。

然后将需要删除的节点del指向pos的下一个节点pos->next，然后将pos的next指针指向del的下一个节点即del->next，最后释放del节点所占用的内存即可。

需要注意的是，在释放del节点的内存后，需要将del指针置为NULL，以避免出现悬挂指针问题。另外，该函数只能删除指定位置pos的后继节点，如果需要删除pos本身，可以调用SLTErase函数。

#pragma once

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

typedef int SLTDataType;

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

//struct SListNode
//{
//	SLTDataType data;
//	struct SListNode* next;
//};
//
//typedef struct SListNode SLTNode;
//单链表的打印
void SLTPrint(SLTNode* phead);

//单链表尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);

//单链表头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);

//单链表的尾插
void SLTPopBack(SLTNode** pphead);

//单链表的尾删
void SLTPopFront(SLTNode** pphead);


// 单链表查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);
// pos之前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
// pos位置删除
void SLTErase(SLTNode** pphead, SLTNode* pos);

// pos后面插入
void SLTInsertAfter(SLTNode* pos, SLTDataType x);
// pos位置后面删除
void SLTEraseAfter(SLTNode* pos);
//单链表的打印
void SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	//while (cur->next != NULL)
	//while(cur != NULL)
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
		//cur++;
	}
	printf("NULL\n");
}

//单链表新节点的创建
SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

//单链表尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySLTNode(x);

	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		// 找尾
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		tail->next = newnode;
	}
}

//单链表头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

//单链表的尾插
void SLTPopBack(SLTNode** pphead)
{
	// 暴力检查
	assert(pphead);
	assert(*pphead);

	// 温柔的检查
	//if (*pphead == NULL)
	//	return;

	// 1、只有一个节点
	// 2、多个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		// 找尾
		//SLTNode* prev = NULL;
		//SLTNode* tail = *pphead;
		//while (tail->next != NULL)
		//{
		//	prev = tail;
		//	tail = tail->next;
		//}

		//free(tail);
		//tail = NULL;

		//prev->next = NULL;

		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}

		free(tail->next);
		tail->next = NULL;
	}	
}

//单链表的尾删
void SLTPopFront(SLTNode** pphead)
{
	// 暴力检查
	assert(pphead);
	assert(*pphead);

	// 温柔的检查
	//if (*pphead == NULL)
	//	return;

	SLTNode* first = *pphead;
	*pphead = first->next;
	free(first);
	first = NULL;
}

//单链表的查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}

		cur = cur->next;
	}

	return NULL;
}

// pos之前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pos);
	assert(pphead);

	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		// 找到pos的前一个位置
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		SLTNode* newnode = BuySLTNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

// pos位置删除
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	//assert(*pphead);

	if (*pphead == pos)
	{
		SLTPopFront(pphead);
	}
	else
	{
		// 找到pos的前一个位置
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

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

// pos后面插入
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

// pos位置后面删除
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);

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

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

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

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

相关文章

数据孤岛如何形成，企业如何破解？

数据孤岛如何形成，企业如何破解？

国内企业数据化现状 在数字化时代&#xff0c;数据已经成为了企业不可或缺的重要资产。企业内部部门或系统之间存在着数据割裂现象&#xff0c;导致数据无法流通和共享&#xff0c;从而形成数据孤岛的现象。对于企业来说&#xff0c;数据孤岛问题是十分普遍的&#xff0c;它阻…
阅读更多...
如何在项目管理中获得更多权威和影响力？这篇文章告诉你！

如何在项目管理中获得更多权威和影响力？这篇文章告诉你！

1 透明力 信息力和感知力是对环境的观察、观察、再观察&#xff0c;这些 观察的结果只有透明出来&#xff0c;才能发挥效用。你要想法把你看到的问题可视化&#xff0c;让决策者和团队都能看到问题。即透明的力量。 1.1 怎么运用透明的力量呢&#xff1f; 我曾在某团队经常听…
阅读更多...
win11 系统安装 wsl

win11 系统安装 wsl

1. 打开虚拟设置 在【开始】搜索【启用或关闭 Windows 功能】&#xff0c;打开Windows 功能对话框&#xff0c;勾选“适用于Linux的Windows子系统”和“虚拟机平台”两个选项。 2. wsl 安装 管理员模式启动powershell 设置wsl版本&#xff1a;wsl --set-default-version 1 更新…
阅读更多...
业务 IT 一体化：华为云 SaaS Package 做到了

业务 IT 一体化：华为云 SaaS Package 做到了

SaaS 这个概念在近两年可谓十分火热&#xff0c;特别是进入到了后疫情时代&#xff0c;似乎离不开 SasS。然而很多人并没有真正理解 SaaS 的概念&#xff0c;对 SaaS 的认知还是比较片面。 你要弄清 SaaS&#xff0c;首先就绕不开 laaS 和 PaaS。下面这张图可以很直观地让你明…
阅读更多...
leetcode40. 组合总和 II (java-回溯算法)

leetcode40. 组合总和 II (java-回溯算法)

组合总和 II leetcode40. 组合总和 II题目描述解题思路代码演示 回溯算法专题 leetcode40. 组合总和 II 来源&#xff1a;力扣&#xff08;LeetCode&#xff09; 链接&#xff1a;https://leetcode.cn/problems/combination-sum-ii 题目描述 给定一个候选人编号的集合 candida…
阅读更多...
【滤波】扩展卡尔曼滤波器

【滤波】扩展卡尔曼滤波器

本文主要翻译自rlabbe/Kalman-and-Bayesian-Filters-in-Python的第11章节11-Extended-Kalman-Filters&#xff08;扩展卡尔曼滤波&#xff09;。 %matplotlib inline#format the book import book_format book_format.set_style()我们发展了线性卡尔曼滤波器的理论。然后在上两…
阅读更多...
Fiddler之日常使用简介

Fiddler之日常使用简介

目录 前言&#xff1a; Fiddler界面简介 一、Fiddler抓取http、https请求配置 二、抓取指定域名会话 三、http请求统计试图 前言&#xff1a; Fiddler是一款功能强大的Web调试工具&#xff0c;它可以帮助开发人员在开发和测试过程中捕获、修改和检查HTTP请求和响应。 使用Fiddl…
阅读更多...
Python基础（11）——Python循环（while、for）

Python基础（11）——Python循环（while、for）

Python基础&#xff08;11&#xff09;——Python循环&#xff08;while、for&#xff09; 文章目录 Python基础&#xff08;11&#xff09;——Python循环&#xff08;while、for&#xff09;目标一. 循环简介1.1 循环的作用1.2 循环的分类 二. while的语法2.1 快速体验 三. w…
阅读更多...
全球开源 AI 游戏开发挑战赛，只等你来！

全球开源 AI 游戏开发挑战赛，只等你来！

我们在之前的文章中 预告过 (*划重点&#xff0c;IP 属地法国)&#xff1a;7 月初&#xff0c;我们将举办一次与 AI 游戏相关的黑客松活动&#xff0c;这是有史以来的首次开源游戏开发挑战赛&#xff0c;借助人工智能工具释放你的创造力&#xff0c;一起打破游戏开发的边界。 比…
阅读更多...
Python自动化测试 软件测试最全教程（附笔记），看完就可就业

Python自动化测试 软件测试最全教程（附笔记），看完就可就业

最近看到很多粉丝在后台私信我&#xff0c;叫我做一期Python自动化测试的教程&#xff0c;其实关于这个问题&#xff0c;我也早就在着手准备了&#xff0c;我录制了一整套完整的Python自动化测试的教程&#xff0c;都上传在B站上面&#xff0c;大家有兴趣的可以去看一下&#x…
阅读更多...
Redis 2023面试5题（二）

Redis 2023面试5题（二）

一、Redis key没设置过期时间却被redis主动删除了 如果一个 Redis 键没有设置过期时间&#xff0c;那么 Redis 无法判断该键是否应该自动删除。因此&#xff0c;如果一个没有设置过期时间的键被 Redis 主动删除了&#xff0c;可能是以下原因之一&#xff1a; 内存不足&#x…
阅读更多...
工程机械比例阀电流采集方案

工程机械比例阀电流采集方案

工程机械的需求量变得越来越大&#xff0c;而关于工程机械&#xff0c;其比例阀的控制问题不容忽视。比例阀是一种新型的液压控制装置。在普通压力阀、流量阀和方向阀上&#xff0c;用比例电磁铁替代原有的控制部分&#xff0c;并按输入的电气信号连续、按比例地对油流的压力、…
阅读更多...
VUE 2X 条件列表渲染 ⑧

VUE 2X 条件列表渲染 ⑧

目录 文章有误请指正&#xff0c;如果觉得对你有用&#xff0c;请点三连一波&#xff0c;蟹蟹支持✨ V u e j s Vuejs Vuejs条件渲染列表渲染 基本列表 Key的原理 列表过滤 列表排序 列表更新小问题 监测数据改变的原理~对象 V u e S e t VueSet VueSet的…
阅读更多...
常见web中间件漏洞复现总结

常见web中间件漏洞复现总结

文章目录 IISPUT漏洞iis6.0 解析漏洞IIS短文件漏洞远程代码执行(RCE-CVE-2017-7269)iis7.x文件解析漏洞HTTP.SYS远程代码执行 (MS15-034) apache未知扩展名解析漏洞AddHandler解析漏洞目录遍历漏洞Apache HTTPD 换行解析漏洞&#xff08;CVE-2017-15715&#xff09; Nginx文件解…
阅读更多...
RabbitMQ入门学习笔记

RabbitMQ入门学习笔记

文章目录 RabbitMQ学习笔记前言1、RabbitMQ概述1.1 MQ概述1.2 RabbitMQ概述 2、RabbitMQ的安装3、RabbitMQ初体验4、工作队列4.1 消息应答4.1.1 消息应答简介4.1.2 消息手动应答 4.2 队列和消息的持久化4.2.1 队列持久化4.2.2 消息持久化 4.3 消息分发4.3.1 不公平分发4.3.2 预…
阅读更多...
[进阶]Java：线程池、处理Runnable、Callable任务、使用Executors得到线程池

[进阶]Java：线程池、处理Runnable、Callable任务、使用Executors得到线程池

什么是线程池&#xff1f; 线程池就是一个可以复用线程的技术。 不实用线程池的问题&#xff1f; 用户每发起一个请求&#xff0c;后台就需要创建一个新线程来处理&#xff0c;下次新任务来了肯定又要创建新线程处理的&#xff0c; 而创建新线程的开销是很大的&#xff0c;并…
阅读更多...
MIT 6.S081 (BOOK-RISCV-REV1)教材第四章内容 --中

MIT 6.S081 (BOOK-RISCV-REV1)教材第四章内容 --中

MIT 6.S081 教材第四章内容 -- 中 引言Debug Trap代码执行流程进入Trap前发生Trap时uservec函数Issue usertrap函数usertrapret函数userret函数 小结 引言 MIT 6.S081 2020 操作系统 本文为MIT 6.S081课程第四章教材内容翻译加整理。 本课程前置知识主要涉及: C语言(建议阅读…
阅读更多...
二进制部署k8集群（上）搭建单机matser和etcd集群

二进制部署k8集群（上）搭建单机matser和etcd集群

1. 单机matser预部署设计 组件部署&#xff1a; 2.操作系统初始化配置 注意&#xff1a;该操作在所有node节点上进行&#xff0c;为k8s集群提供适合的初始化部署环境 #关闭防火墙 systemctl stop firewalld systemctl disable firewalld iptables -F && iptables -t n…
阅读更多...
985大学学生故意挂科为延毕？赖校族的无奈。

985大学学生故意挂科为延毕？赖校族的无奈。

“他室友挂了4科&#xff0c;答辩随便写了几句&#xff0c;一问三不知。” “然后呢&#xff1f;他室友延毕了吗&#xff1f;” “没有。导员找他谈话&#xff0c;说让他室友按时毕业&#xff0c;因为想延毕的人太多了&#xff0c;别人挂的都比他室友多。” 以上对话不仅仅是…
阅读更多...
PLC原理及PLC+FPGA（SOC）架构方案简介

PLC原理及PLC+FPGA（SOC）架构方案简介

一、PLC原理简介 工业生产和科技的发展都离不开PLC的自动化控制&#xff0c;PLC可以广义的理解为&#xff1a; 集中的继电器延伸控制柜&#xff0c;实际的生产应用中&#xff0c;PLC大大的节省了工业控制的成本&#xff0c;加强了设备的集中管理和自动控制。 PLC&#xff08…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023