单链表（C/C++）

news2024/11/28 18:38:47

        本篇将给出单链表的实现，头部插入/删除，尾部插入/删除，元素查找，指定位置前插入数据，指定位置之后插入元素，删除当前元素，删除当前元素之后的元素。

        在给出这些操作，先给出单链表的定义，之后还会给出一些链表的扩展。

1.什么是单链表

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

        以上为链表的定义，那么什么是单链表呢，就是在链表中的元素只存在数据域和指针域，指针域存放的是下一个元素的地址。即：

        其中的火车头表示链表的头街点，对于单链表来说，分为带头结点的单链表和不带头结点的单链表。 因为在平时使用中，对于不带头结点的单链表使用得最为频繁，所以本篇以不带头结点的单链表为重点。（带头结点的单链表的头结点为：存储第一个元素位置的结点。而平时说的头结点指第一个结点）。

        为什么需要用指针来保存下一个结点的位置呢？

        因为链表中的每个元素都是独立申请的（需要插入数据时才会去申请一块结点的空间），所以需要使用指针来保存下一个结点位置。方便之后查找。

2.链表和顺序表的优点/缺点

        顺序表和链表都属于数据结构中的线性结构，那么这两种线性数据结构有什么区别呢？

        1.存储方式上：顺序表的存储为逻辑相邻+物理项链；而链表的存储方式仅仅为逻辑相邻，使用指针作为链接。

        2.插入和删除操作的效率：顺序表的插入和删除操作都需要移动元素来维持原来的相对顺序，平均时间复杂度为O(n)；链表的插入和删除操作只需要调整相对应的指针，无需移动元素，平均时间复杂度为O(1)。

        3.随机访问的效率：对于顺序表来说，元素的在内存中的存储是连续的，可以直接通过下标进行访问，时间复杂度为O(1)；对于链表来说，由于元素在内存中是不连续存储的，需要通过指针依次访问查找，时间复杂度为O(n)。

        4.空间利用上：对于顺序表来说，每次开辟或者增容的空间，可能会存在浪费的情况；而对于链表来说，虽然开辟的空间都能用到，但存在许多的内存碎片。

3.单链表操作的实现

        以下为不带头结点的单链表的抽象数据结构，以及对应的一些操作。

#define _CRT_SECURE_NO_WARNINGS 1   //在vs2022中解除对部分函数的警告
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int DataType;

typedef struct Node {
	DataType data;
	struct Node* next;
}SLTNode;

//打印单链表
void SLTPrint(SLTNode* phead);

//头部插入删除/尾部插入删除
void SLTPushBack(SLTNode** pphead, DataType x);
void SLTPushFront(SLTNode** pphead, DataType x);
void SLTPopBack(SLTNode** pphead);
void SLTPopFront(SLTNode** pphead);

//单链表的查找
SLTNode* SLTFind(SLTNode* phead, DataType x);

//指定位置之前插入
void SLTInsert(SLTNode** pphead, SLTNode* position, DataType x);
//指定位置之后插入
void SLTInsertAfter(SLTNode* position, DataType x);

//指定位置删除/指定位置后删除
void SLTErase(SLTNode** pphead, SLTNode* position);
void SLTEraseAfter(SLTNode* position);

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

        对于以上的函数，我们可以发现：只有打印当前链表和查找数据传入头结点的一级指针，而其他有关头结点的操作传入的都是头结点的二级指针，是因为：

        以下为对应函数的实现方式，在每个函数中都有对应的注释解释：

//打印所有的元素
void SLTPrint(SLTNode* phead) {
	//先判断当前链表是否为NULL
	if (phead == NULL) {
		printf("该链表没有元素!\n");
		return;
	}
	SLTNode* current = phead;
	while (current) {
		printf("%d->", current->data);
		current = current->next;
	}
	printf("NULL\n");
}

//创建一个新的结点
SLTNode* CreateNode(DataType x) {
	SLTNode* newNode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newNode == NULL) {
		perror("MALLOC:");
		exit(1);
	}
	newNode->data = x;
	newNode->next = NULL;
	return newNode;
}

//尾结点插入
void SLTPushBack(SLTNode** pphead, DataType x) {
	//传过来的单链表地址不能为NULL
	assert(pphead);
	SLTNode* newNode = CreateNode(x);
	//若需要插入的为头结点,直接插入
	if (*pphead == NULL) {
		*pphead = newNode;
		return;
	}
	//若不为头结点，找到最后一个结点
	SLTNode* current = *pphead;
	while (current->next) {
		current = current->next;
	}
	//此时current的下一个为NULL
	current->next = newNode;
	return;
}

//头结点插入
void SLTPushFront(SLTNode** pphead, DataType x) {
	//传过来的头结点指针不能为NULL
	assert(pphead);
	SLTNode* newNode = CreateNode(x);
	//若头结点为NULL，直接插入
	if (*pphead == NULL) {
		*pphead = newNode;
		return;
	}
	//将新节点的指针指向当前头结点
	newNode->next = *pphead;
	//头结点移动
	*pphead = newNode;
	return;
}

//删除尾结点
void SLTPopBack(SLTNode** pphead) {
	//删除结点，头结点和头结点地址都不能为NULL
	assert(pphead && (*pphead));
	//若单单链表只有一个结点
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
		return;
	}
	//若只有头结点一个元素
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
		return;
	}

	//找到尾结点，同时需要找到尾结点的前一个结点，便于删除
	SLTNode* current = *pphead;
	SLTNode* previous = *pphead;
	//当指针为NULL是表明为尾结点
	while (current->next) {
		previous = current;
		current = current->next;
	}
	//当前current为最后一个结点，previous为倒数第二个结点
	free(current);
	current = NULL;
	previous->next = NULL;
	return;
}

//头结点位置删除
void SLTPopFront(SLTNode** pphead) {
	//删除结点，头结点和头结点地址都不能为NULL
	assert(pphead && (*pphead));
	SLTNode* current = *pphead;
	//将头结点指向下一个结点
	*pphead = current->next;
	free(current);
	current = NULL;
	return;
}

//查找元素
SLTNode* SLTFind(SLTNode* phead, DataType x) {
	if (phead == NULL) {
		printf("该链表没有任何信息\n");
		return NULL;
	}
	SLTNode* current = phead;
	while (current) {
		if (current->data == x) {
			return current;
		}
		current = current->next;
	}
	return NULL;
}

//在position前插入元素
void SLTInsert(SLTNode** pphead, SLTNode* position, DataType x) {
	//头结点的地址不能为NULL，对应位置的元素也不能为NULL
	assert(pphead);
	assert(position);
	//既然对应位置不能为NULL，说明链表一定存在元素，链表头结点也不能为NULL
	assert(*pphead);
	//如果此时只有头结点一个元素,且刚好为position
	if (*pphead == position) {
		SLTNode* newNode = CreateNode(x);
		newNode->next = *pphead;
		*pphead = newNode;
		return;
	}
	//需要找打position前的一个元素
	SLTNode* current = *pphead;
	while (current->next != position&&current!=NULL) {
		current = current->next;
	}
	if (current == NULL) {
		printf("没找不到该元素位置，插入失败！\n");
		return;
	}
	else {
		//当前current为position的前一个元素
		SLTNode* newNode = CreateNode(x);
		//将新生成的结点链接起来
		newNode->next = position;
		current->next = newNode;
	}
}

void SLTInsertAfter(SLTNode* position, DataType x) {
	assert(position);
	SLTNode* newNode = CreateNode(x);
	//下面两句不能调换顺序！
	newNode->next = position->next;
	position->next = newNode;
}

void SLTDestroy(SLTNode** pphead) {
	//传过来的链表不能为NULL
	assert(pphead);
	assert(*pphead);
	SLTNode* current = *pphead;
	if (current != NULL) {
		SLTNode* next = current->next;
		free(current);
		current = next;
	}
	current = NULL;
	*pphead = NULL;
}

//指定位置删除
void SLTErase(SLTNode** pphead, SLTNode* position) {
	//头结点及其地址不能为NULL
	assert(pphead);
	assert(*pphead);
	assert(position);
	//如果删除的为第一个结点
	if (position == *pphead) {
		*pphead = (*pphead)->next;
		free(position);
		position = NULL;
		return;
	}
	//找到对应位置的前一个结点
	SLTNode* current = *pphead;
	while (current->next != position&&current!=NULL) {
		current = current->next;
	}
	//找到最后一个结点都没有找到position
	if (current == NULL) {
		printf("没有找到对应结点!\n");
		return;
	}
	else {
		//当前current指针指向position的前一个位置
		current->next = position->next;
		free(position);
		position = NULL;
	}
}

//指定位置之后删除
void SLTEraseAfter(SLTNode* position) {
	assert(position);
	//之后一个结点也不能为NULL
	assert(position->next);
	SLTNode* next = position->next;
	position->next = next->next;
	free(next);
	next = NULL;
}

        以下为所有代码，及其运行测试结果： 

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int DataType;

typedef struct Node {
	DataType data;
	struct Node* next;
}SLTNode;

//打印所有的元素
void SLTPrint(SLTNode* phead) {
	//先判断当前链表是否为NULL
	if (phead == NULL) {
		printf("该链表没有元素!\n");
		return;
	}
	SLTNode* current = phead;
	while (current) {
		printf("%d->", current->data);
		current = current->next;
	}
	printf("NULL\n");
}

//创建一个新的结点
SLTNode* CreateNode(DataType x) {
	SLTNode* newNode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newNode == NULL) {
		perror("MALLOC:");
		exit(1);
	}
	newNode->data = x;
	newNode->next = NULL;
	return newNode;
}

//尾结点插入
void SLTPushBack(SLTNode** pphead, DataType x) {
	//传过来的单链表地址不能为NULL
	assert(pphead);
	SLTNode* newNode = CreateNode(x);
	//若需要插入的为头结点,直接插入
	if (*pphead == NULL) {
		*pphead = newNode;
		return;
	}
	//若不为头结点，找到最后一个结点
	SLTNode* current = *pphead;
	while (current->next) {
		current = current->next;
	}
	//此时current的下一个为NULL
	current->next = newNode;
	return;
}

//头结点插入
void SLTPushFront(SLTNode** pphead, DataType x) {
	//传过来的头结点指针不能为NULL
	assert(pphead);
	SLTNode* newNode = CreateNode(x);
	//若头结点为NULL，直接插入
	if (*pphead == NULL) {
		*pphead = newNode;
		return;
	}
	//将新节点的指针指向当前头结点
	newNode->next = *pphead;
	//头结点移动
	*pphead = newNode;
	return;
}

//删除尾结点
void SLTPopBack(SLTNode** pphead) {
	//删除结点，头结点和头结点地址都不能为NULL
	assert(pphead && (*pphead));
	//若单单链表只有一个结点
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
		return;
	}
	//若只有头结点一个元素
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
		return;
	}

	//找到尾结点，同时需要找到尾结点的前一个结点，便于删除
	SLTNode* current = *pphead;
	SLTNode* previous = *pphead;
	//当指针为NULL是表明为尾结点
	while (current->next) {
		previous = current;
		current = current->next;
	}
	//当前current为最后一个结点，previous为倒数第二个结点
	free(current);
	current = NULL;
	previous->next = NULL;
	return;
}

//头结点位置删除
void SLTPopFront(SLTNode** pphead) {
	//删除结点，头结点和头结点地址都不能为NULL
	assert(pphead && (*pphead));
	SLTNode* current = *pphead;
	//将头结点指向下一个结点
	*pphead = current->next;
	free(current);
	current = NULL;
	return;
}

//查找元素
SLTNode* SLTFind(SLTNode* phead, DataType x) {
	if (phead == NULL) {
		printf("该链表没有任何信息\n");
		return NULL;
	}
	SLTNode* current = phead;
	while (current) {
		if (current->data == x) {
			return current;
		}
		current = current->next;
	}
	return NULL;
}

//在position前插入元素
void SLTInsert(SLTNode** pphead, SLTNode* position, DataType x) {
	//头结点的地址不能为NULL，对应位置的元素也不能为NULL
	assert(pphead);
	assert(position);
	//既然对应位置不能为NULL，说明链表一定存在元素，链表头结点也不能为NULL
	assert(*pphead);
	//如果此时只有头结点一个元素,且刚好为position
	if (*pphead == position) {
		SLTNode* newNode = CreateNode(x);
		newNode->next = *pphead;
		*pphead = newNode;
		return;
	}
	//需要找打position前的一个元素
	SLTNode* current = *pphead;
	while (current->next != position&&current!=NULL) {
		current = current->next;
	}
	if (current == NULL) {
		printf("没找不到该元素位置，插入失败！\n");
		return;
	}
	else {
		//当前current为position的前一个元素
		SLTNode* newNode = CreateNode(x);
		//将新生成的结点链接起来
		newNode->next = position;
		current->next = newNode;
	}
}

void SLTInsertAfter(SLTNode* position, DataType x) {
	assert(position);
	SLTNode* newNode = CreateNode(x);
	//下面两句不能调换顺序！
	newNode->next = position->next;
	position->next = newNode;
}

void SLTDestroy(SLTNode** pphead) {
	//传过来的链表不能为NULL
	assert(pphead);
	assert(*pphead);
	SLTNode* current = *pphead;
	if (current != NULL) {
		SLTNode* next = current->next;
		free(current);
		current = next;
	}
	current = NULL;
	*pphead = NULL;
}

//指定位置删除
void SLTErase(SLTNode** pphead, SLTNode* position) {
	//头结点及其地址不能为NULL
	assert(pphead);
	assert(*pphead);
	assert(position);
	//如果删除的为第一个结点
	if (position == *pphead) {
		*pphead = (*pphead)->next;
		free(position);
		position = NULL;
		return;
	}
	//找到对应位置的前一个结点
	SLTNode* current = *pphead;
	while (current->next != position&&current!=NULL) {
		current = current->next;
	}
	//找到最后一个结点都没有找到position
	if (current == NULL) {
		printf("没有找到对应结点!\n");
		return;
	}
	else {
		//当前current指针指向position的前一个位置
		current->next = position->next;
		free(position);
		position = NULL;
	}
}

//指定位置之后删除
void SLTEraseAfter(SLTNode* position) {
	assert(position);
	//之后一个结点也不能为NULL
	assert(position->next);
	SLTNode* next = position->next;
	position->next = next->next;
	free(next);
	next = NULL;
}

void Test01() {
	SLTNode* phead = NULL;
	SLTPushBack(&phead, 1);
	SLTPushBack(&phead, 2);
	SLTPushBack(&phead, 3);
	SLTPushBack(&phead, 4);
	SLTPrint(phead);  // 1 2 3 4

	SLTPushFront(&phead, 8);
	SLTPushFront(&phead, 7);
	SLTPushFront(&phead, 9);
	SLTPrint(phead);  // 9 7 8 1 2 3 4

	SLTPopBack(&phead);
	SLTPopBack(&phead);
	SLTPopBack(&phead);
	SLTPrint(phead);  //9 7 8 1

	SLTPopFront(&phead);
	SLTPopFront(&phead);
	SLTPopFront(&phead); 
	SLTPrint(phead);  //1

	SLTNode* P = SLTFind(phead,1);
	if (P != NULL) {
		printf("找到了！\n");  //找到了！
		printf("%d\n", P->data);//1
	}
	else {
		printf("未找到!\n");
	}

	SLTInsert(&phead, P, 100);
	SLTInsertAfter(P, 8); 
	SLTPrint(phead);	//100 1 8

	SLTPushBack(&phead, 12);
	SLTPushBack(&phead, 13);
	SLTPushBack(&phead, 14);
	SLTPrint(phead);	//100 1 8 12 13 14

	SLTEraseAfter(P);   
	SLTErase(&phead,P);
	SLTPrint(phead);    //100 12 13 14

	SLTDestroy(&phead);
}

int main() {
	Test01();
	return 0;
}

        测试结果：

        以上就为单链表的所有操作。

4. 链表的分类

        链表的结果非常多样，结合以下情况组合起来一共就有8种（2*2*2）链表结构：

        带头或者不带头：

        单向或者双向：

         循环与不循环:

        尽管有八种链表结构，但是其中用得最多的是：不带头结点的不循环单向链表、带头结点的循环双向链表。 

         

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

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

相关文章

Jupyter Notebook安装以及简单使用教程

Jupyter Notebook安装以及简单使用教程

Jupyter Notebook安装以及简单使用教程 本文章将&#xff0c;简要的讲解在已经拥有Python环境下如何进行Jupyter Notebook的安装。并且简短的介绍Jupyter Notebook的使用方法。 Jupyter Notebook是什么 Jupyter Notebook是一个基于Web的交互式计算环境&#xff0c;它支持多种…
阅读更多...
1.21 day6 IO网络编程

1.21 day6 IO网络编程

网络聊天室 服务端 #include <myhead.h> #define PORT 8888 #define IP "192.168.122.48" struct MSG {char tyep;char name[20];char buf[128]; }; typedef struct Node {struct sockaddr_in cin;struct Node*next; }*node;int main(int argc, const char *…
阅读更多...
【C++进阶07】哈希表and哈希桶

【C++进阶07】哈希表and哈希桶

一、哈希概念 顺序结构以及平衡树中 元素关键码与存储位置没有对应关系 因此查找一个元素 必须经过关键码的多次比较 顺序查找时间复杂度为O(N) 平衡树中为树的高度&#xff0c;即O( l o g 2 N log_2 N log2​N) 搜索效率 搜索过程中元素的比较次数 理想的搜索方法&#xff1a…
阅读更多...
如何一键生成原创文案？方法大揭密

如何一键生成原创文案？方法大揭密

在当今信息爆炸的时代&#xff0c;优秀的文案变得尤为重要。无论是网站、广告还是社交媒体&#xff0c;都需要吸引用户注意力的高质量、有吸引力的文案。不过&#xff0c;创作出这样的文案并不容易&#xff0c;需要投入大量的时间和精力。那么&#xff0c;有没有一种方法可以一…
阅读更多...
Java 面向对象 06 对象内存图（黑马）

Java 面向对象 06 对象内存图（黑马）

之前设计的如下图&#xff1a; 方法区和内存在物理上是一块的&#xff0c;但是有不好的地方&#xff0c;所以变成了这种形式&#xff1a; 一个对象的内存图&#xff1a; 在创建对象时虚拟机至少做了以下七步&#xff1a; 解释&#xff1a; 第一步&#xff1a; 第二步&#x…
阅读更多...
视频格式转换软件，无忧转换畅享愉悦

视频格式转换软件，无忧转换畅享愉悦

在这个视频无处不在的时代&#xff0c;一款好的视频格式转换工具显得尤为重要。它不仅解决了你的燃眉之急&#xff0c;更让你畅享快速转换和简单操作带来的愉悦体验。现在就加入我们&#xff0c;开启全新的视频转换之旅吧&#xff01; 所需工具&#xff1a; 一个【媒体梦工厂…
阅读更多...
【Leetcode】2788. 按分隔符拆分字符串

【Leetcode】2788. 按分隔符拆分字符串

文章目录 题目思路代码 题目 题目链接 给你一个字符串数组 words 和一个字符 separator &#xff0c;请你按 separator 拆分 words 中的每个字符串。 返回一个由拆分后的新字符串组成的字符串数组&#xff0c;不包括空字符串 。 注意 separator 用于决定拆分发生的位置&#…
阅读更多...
一区优化直接写：KOA-CNN-BiLSTM-Attention开普勒优化卷积、长短期记忆网络融合注意力机制的多变量回归预测程序！

一区优化直接写：KOA-CNN-BiLSTM-Attention开普勒优化卷积、长短期记忆网络融合注意力机制的多变量回归预测程序！

适用平台&#xff1a;Matlab 2023版及以上 KOA开普勒优化算法&#xff0c;于2023年5月发表在SCI、中科院1区Top顶级期刊《Knowledge-Based Systems》上。 该算法提出时间很短&#xff0c;目前还没有套用这个算法的文献。 同样的&#xff0c;我们利用该新鲜出炉的算法对我们的…
阅读更多...
Pandas--简介(1)

Pandas--简介(1)

Pandas 简介 Pandas 是一个开源的数据分析和数据处理库&#xff0c;它是基于 Python 编程语言的。Pandas 提供了易于使用的数据结构和数据分析工具&#xff0c;特别适用于处理结构化数据&#xff0c;如表格型数据&#xff08;类似于Excel表格&#xff09;。Pandas 是数据科学和…
阅读更多...
Spring boot项目java bean和xml互转

Spring boot项目java bean和xml互转

Spring boot项目实现java bean和xml互转 项目场景&#xff1a;互转方法使用jackson进行互转使用jaxws进行xml与bean的互转 搞定收工&#xff01; 项目场景&#xff1a; 工作中需要给下游第三方收费系统做数据挡板&#xff0c;由于下游系统使用的是soap webservice,里面涉及各种…
阅读更多...
UE5 C++学习笔记 常用宏的再次理解

UE5 C++学习笔记 常用宏的再次理解

1.随意创建一个类&#xff0c;他都有UCLASS()。GENERATED_BODY()这样的默认的宏。 UCLASS() 告知虚幻引擎生成类的反射数据。类必须派生自UObject. &#xff08;告诉引擎我是从远古大帝UObject中&#xff0c;继承而来&#xff0c;我们是一家人&#xff0c;只是我进化了其他功能…
阅读更多...
【C++修行之道】竞赛常用库函数（sort，min和max函数，min_element和max_element、nth_element）

【C++修行之道】竞赛常用库函数（sort，min和max函数，min_element和max_element、nth_element）

目录 一、sort 1.1sort简介 语法 参数 功能 适用容器 1.2sort的用法 1.3自定义比较函数 示例 1265蓝桥题 —— 排序 二、min和max函数 三、min_element和max_element 497蓝桥题 —— 成绩分析 四、nth_element 一、sort 1.1sort简介 sort函数包含在头文件<a…
阅读更多...
如何在WordPress中使用 AI 进行 SEO(12 个工具)

如何在WordPress中使用 AI 进行 SEO(12 个工具)

您想在 WordPress 中使用 AI 进行 SEO 吗&#xff1f; 人工智能正在对 SEO 行业产生重大影响。已经有优秀的人工智能 SEO 工具&#xff0c;您可以使用它们来提高您的 SEO 排名&#xff0c;而无需付出太多努力。 在本文中&#xff0c;我们将向您展示如何通过我们精心挑选的工具…
阅读更多...
Qt 开发环境配置 vs和Qt creator

Qt 开发环境配置 vs和Qt creator

Qt 开发环境配置 vs和Qt creator 1、安装的软件 1、vs_Enterprise.exe 2、Qt creator (最好是最新的版本,低版本不支持vs2019) 下载地址&#xff1a;https://gofile-3535697530.cn1.quickconnect.cn/sharing/zMCh5ENgZ 密码&#xff1a;qt_dev 2、Qt Creator配置 1、打开…
阅读更多...
检索增强生成中的创新

检索增强生成中的创新

每日推荐一篇专注于解决实际问题的外文，精准翻译并深入解读其要点，助力读者培养实际问题解决和代码动手的能力。 欢迎关注公众号（NLP Research），及时查看最新内容 原文标题：Innovations In Retrieval Augmented Generation 原文地址：https://medium.com/emalpha/innov…
阅读更多...
springsecurity集成kaptcha功能

springsecurity集成kaptcha功能

前端代码 本次采用简单的html静态页面作为演示&#xff0c;也可结合vue前后端分离开发&#xff0c;复制就可运行测试 项目目录 登录界面 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>Title</…
阅读更多...
x-cmd pkg | speedtest-cli - 网络速度测试工具

x-cmd pkg | speedtest-cli - 网络速度测试工具

目录 简介首次用户功能特点竞品和相关作品进一步探索 简介 speedtest-cli 是一个网络速度测试工具&#xff0c;用于测试计算机或服务器与速度测试服务器之间的网络连接速度。 它使用 speedtest.net 测试互联网带宽&#xff0c;可以帮助用户获取网络的上传和下载速度、延迟等参…
阅读更多...
Java项目：ssm框架基于spring+springmvc+mybatis框架的民宿预订管理系统设计与实现（ssm+B/S架构+源码+数据库+毕业论文）

Java项目：ssm框架基于spring+springmvc+mybatis框架的民宿预订管理系统设计与实现（ssm+B/S架构+源码+数据库+毕业论文）

一、项目简介 本项目是一套ssm827基于SSM框架的民宿预订管理系统设计与实现&#xff0c;主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的Java学习者。 包含&#xff1a;项目源码、数据库脚本等&#xff0c;该项目附带全部源码可作为毕设使用。 项目都经过严格调…
阅读更多...
stm32内存分配博客笔记

stm32内存分配博客笔记

原文&#xff1a; stm32内存分配 笔记&#xff1a; 1、向量表与代码段&#xff1b;根据Cortex-M3权威指南描述&#xff0c;系统复位后&#xff0c;在向量表异常0处保存的是堆栈起始地址&#xff0c;而后紧跟中断向量表 2、可以从链接脚本.ld文件中看到终端向量表第一个被链接…
阅读更多...
品牌百度百科词条怎么写？

品牌百度百科词条怎么写？

在互联网时代&#xff0c;品牌的影响力愈发重要&#xff0c;而百度百科作为我国最大的百科全书&#xff0c;更是塑造品牌形象、传播品牌价值的重要平台。如何撰写一篇高质量的百度百科品牌词条&#xff0c;成为了众多企业和品牌关注的焦点。品牌百度百科词条怎么写&#xff1f;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023