用纯C实现单链表

news2024/11/26 0:54:05

前言

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

链表的创建

需要创建一个小项目工程
创建三个文件
⭐SListNode.h放单链表的头文件，函数声明
⭐SListNode.c放单链表的函数
⭐test.c是主函数，存放框架，测试函数

(1)创建一个链表

首先，我们可以类比顺序表，在创建顺序表的时候，是用一个结构体来创建的,所以我们可以用结构体创建，包括数据和下一个结构体的地址(用来找到下一个地址)

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

为什们用动态开辟？

首先我们知道局部变量出了作用域，就自己消除了，如果我们在一个函数中自己申请空间用来创建结构体，如果我们出了这个函数，我们就找不到这个链表，但是如果用动态空间，所开辟的空间在堆上存放，即便我们出了作用域，我们都来能找到这个链表，这就是我们动态开辟的原因。

(2)动态开辟单个链表

我们上面创建一个链表，只是创建了一个结构体，只是每一个链表中的元素有什们，而我们这个是给链表装东西，将链表的内容填充了。

//动态开辟一个链表
SLTNode* BuySLTNode(SLDataType n)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = n;
	newnode->next = NULL;
}

(3)创建n个链表

我们开辟完单个链表，链表的内容都有了，但是这个链表只有一个，我们要创建的链表不是只有一个，是需要我们将他们都串起来。所以我们下一步就是创建n个链表。具体的注意事项，我们都放在了代码的注释当中。

//创建n个链表
SLTNode* CreatSLT(int n)
{
	//这是为了省事，直接用循环创建n个单个链表
	int i = 0;
	//头指针是不能动的，因为最后返回的是链表的头指针
	//所以我们设置一个尾指针，先和头指针相同，移动的
	//时候移动尾指针就好了。
	SLTNode* phead = NULL;
	SLTNode* ptail = NULL;
	for (i = 0; i < n; i++)
	{
		SLTNode* newnode = BuySLTNode(i);
		//如果头指针是空指针，
		//那么先将头指针和尾指针还有新创建的单个链表设为相等
		if (phead == NULL)
		{
			phead = ptail = newnode;
		}
		else
		{
			ptail->next = newnode;
			ptail = newnode;
		}
	}
	return phead;
}

(4)打印链表

我们上面创建了链表，我们为了显示我们的链表，我们就要打印链表，进而显示我们链表，我们怎么打印链表，就仔细看代码就可以了，大家多看看注释，这很重要。

//打印链表
void PrintSLT(SLTNode* phead)
{
	//我们想一想，如果链表为空可不可以打印
	//很显然是可以的，我们打印一个空指针就很OK
	//所以我们不对他进行断言

	//我们一般不动我们的头指针，
	//所以我们要找一个东西代替他
	SLTNode* cur = phead;
	//我们打印肯定需要循环，是循环就需要条件，
	//我们循环的条件就是
	//直到我们遇到最后一个链表的next了，也就是空指针的时候
	while (cur ！= NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	//因为最后一个肯定是空指针
	//为了打印的美观，我们打印一个空指针
	printf("NULL");
	
}

(5)单链表的尾插

现在我们将一个简易的链表做了出来，我们要实现链表的功能。
首先实现尾插的功能，但是有很多注意的事项，我们先看两段有点问题的代码，首先先自己想一下问题是什们，然后自己再看答案，我们只要解决了这个问题我们的功能基本上就解决了

问题一

//单链表尾插
void SLTPushBack(SLTNode* phead, SLDataType n)
{
	SLTNode* newnode = BuySLTNode(n);
	SLTNode* tail = phead;
	while (tail)
	{
		tail = tail->next;
	}
	tail = newnode;
}

其实这个问题还是比较容易发现的，只要我们画个图，我们就能发现这个条件其实是有问题的，当tail结束循环的时候tail等于NULL，而让我们新创建的链表等于空指针，没有任何作用。所以这个条件有问题。
其实这个问题还是很简单的，还有一个问题才是重点。我们先修改这个代码

问题二

//单链表尾插
void SLTPushBack(SLTNode* phead,SLTDataType n)
{
	SLTNode* newnode = BuySLTNode(n);
	SLTNode* tail = phead;
	while (tail->next)
	{
		tail = tail->next;
	}
	tail->next= newnode;
}

现在我们将循环的条件改变了，当tail的next等于空指针，我们在将tail的next赋值位新链表的地址我们就很好的修改了。

但是如果我们的链表为空的时候，我们能不能在尾插内容呢？
答案显而易见，当然是可以的，但是这时tail是NULL,我们在进行这个条件的时候tail->next，这时就发生了空指针的解引用。

这时候有的同学就说，我们可以用if条件区别一下空指针就可以了呀。我们先看代码。和调试。

//单链表尾插
void SLTPushBack(SLTNode* phead,SLDataType n)
{
	SLTNode* newnode = BuySLTNode(n);
	SLTNode* tail = phead;
	if (phead == NULL)
	{
		tail = phead = newnode;
	}
	else
	{
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

我们发现在我们进行测试的时候，我们开头是空指针的时候，并没有尾插上，到底是什们原因呢？
在这里插入图片描述

我们知道，形参的改变并不会影响实参。我们在进行尾插的时候，传的是一级指针，在我们的函数调用中phead是NULL，在if条件下将phead赋值为newnode,但是再出了这个函数后，我们的phead还是NULL，并不会改变，因为，形参的改变并不会影响实参。

如果我们不理解，可以不要将phead想象成一个指针，就把他当作一个整型，在函数中，我们改变他，只是在函数的作用域中有用，一旦出了这个作用域，那么改变的量就不会起作用，他是多少就是多少，如果想在函数中改变他的值，我们就需要传该数的指针，通过改变指针的方式，才能改变该数的实参。

所以我们想要改变phead，我们需要通过phead的指针来改变phead也就要用到二级指针。

//单链表尾插
void SLTPushBack(SLTNode** pphead,SLDataType n)
{
	SLTNode* newnode = BuySLTNode(n);
	
	if (*pphead == NULL)
	{
		 *pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

(6)单链表的尾删

单链表尾删，我们就是将最后一个链表的上一个链表的next设置为NULL
怎么找最后一个链表的上一个链表，具体操作看代码注释。

//单链表尾删
void SLTPopBack(SLTNode* phead)
{
	//我们在移动的时候一般不移动phead
	//所以我们一般都使用另一个来代替phead
	SLTNode* tail = phead;
	//因为我们要将tail的前面的链表找到所以
	//创建一个prev
	SLTNode* prev = NULL;
	while (tail->next)
	{
		prev = tail;
		tail = tail->next;
	}
	free(tail);
	//将prev的next滞空，就相当于删除了
	prev->next = NULL;
}

这个其实也是有问题的，我们如果只剩下一个结点，我们要找tail前一个结点就没有，所以我们这个需要分类讨论。
请看下面代码

//单链表尾删
void SLTPopBack(SLTNode* phead)
{
	//我们只有一个结点，分类讨论
	if (phead->next == NULL)
	{
		free(phead);
		//和上面一样的问题
		phead = NULL;
	}
	else
	{
		//我们在移动的时候一般不移动phead
		//所以我们一般都使用另一个来代替phead
		SLTNode* tail = phead;
		//因为我们要将tail的前面的链表找到所以
		//创建一个prev
		SLTNode* prev = NULL;
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		//将prev的next滞空，就相当于删除了
		prev->next = NULL;
	}
	
}

我们其实还有问题，在注释上也写到了，我们形参的改变不影响实参的改变，并不能将phead变为空指针，所以我们还是要用二级指针。

//单链表尾删
void SLTPopBack(SLTNode** pphead)
{
	//如果链表为空，我们就不能再删了
	//需要断言
	assert(*pphead);
	//我们只有一个结点，分类讨论
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//我们在移动的时候一般不移动phead
		//所以我们一般都使用另一个来代替phead
		SLTNode* tail = *pphead;
		//因为我们要将tail的前面的链表找到所以
		//创建一个prev
		SLTNode* prev = NULL;
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		//将prev的next滞空，就相当于删除了
		prev->next = NULL;
	}
}

(7)单链表的头插

其实我们的单链表的头插和头删，还是要用二级指针。
头插其实很简单，就是先创建一个结点，然后将结点的next赋值为第一个节点的地址，就可以了。

//单链表的头插
void SLTPushFront(SLTNode** pphead, SLDataType n)
{
	SLTNode* newnode = BuySLTNode(n);
	newnode->next = *pphead;
	//头插完，将插完的第一个设为头结点
	*pphead = newnode;
}

(8)单链表的头删

头删就是将头结点放到下一个结点就行

//单链表头删
void SLTPopFront(SLTNode** pphead)
{
	//防止空指针的解引用
	assert(*pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

(9)链表的查找

因为我们后面要进行，在链表的中间进行添加和删除，我们就是需要，先找到我们需要在哪里添加和删除，我们就要进行查找。因为查找我们不需要进行修改头指针，所以我们就不需要用二级指针。用一级指针就可以了。
我们知道了为什们查找，所以我们就看下面的代码吧。

//链表的查找
SLTNode* SLTFind(SLTNode* phead, SLDataType n)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == n)
			return cur;
		else
			cur = cur->next;
	}
	return NULL;
}

(10)在pos后插入

我们先用查找函数，找到我们要插入的位置，也就是pos,然后我们再将需要插入的东西插入就可以了。

//在pos后进行插入
void SLTInsertAfter(SLTNode* pos, SLDataType n)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(n);
	newnode->next = pos->next;
	pos->next = newnode;
}

(11)在pos前插入

其实是一样的道理，但是我们需要找到pos前的结点，我们就需要从头开始寻找，找到pos前的结点，然后在进行改变。
但是如果我们在第一个结点前插入，我们就变成了头插，我们就需要改变头指针，所以我们就要用二级指针。

//在pos前进行插入
void SLTInsertFront(SLTNode** pphead,SLTNode* pos, SLDataType n)
{
	assert(pos);
	
	if (*pphead == pos)
	{
		SLTPushFront(pphead, n);
	}
	else
	{
		SLTNode* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		SLTNode* newnode = BuySLTNode(n);
		cur->next = newnode;
		newnode->next = pos;
	}
}

(12)删除pos之后的结点

这个非常简单，我们直接看代码，注释有解释。

//删除pos之后
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	//如果pos是最后一个，那么我们还删什们
	//就直接返回就行，不删除
	if (pos->next == NULL)
	{
		return;
	}
	else
	{
		SLTNode* nextNode = pos->next;
		pos->next = nextNode->next;
		free(nextNode);
		//nextNode = NULL;
	}
}

(13)删除pos位置的结点

这个类比就行了，直接看代码，非常简单的。我们删除还可能是头删，所以我们还是用二级指针。注释解释

//删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pos);
	//就是头删就直接调用就可以了
	if (*pphead == NULL)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		cur->next = pos->next;
		free(pos);
	}
}

(14)单链表的释放

就是动态开放完，然后再用free释放。直接上代码

//单链表的释放
void SLTDestroy(SLTNode** pphead)
{
	SLTNode* cur = *pphead;
	//循环一个一个释放
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
}

总结

其实对于我们的单链表，我们就基本上讲完了，其中最关键的问题，也是最难的问题就是我们要理解为什们要用二级指针。只要理解了这一点，我相信大家一定可以钻研明白。

还有一个问题就是，我们对于在主函数，就不进行包装了，我们自己测试就可以了，我们最后将函数的声明和实现给大家。
希望大家一起进步一起加油！！！！！

SListNode.h代码

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef int SLDataType;

//创建一个单链表
typedef struct SListNode
{
	SLDataType data;
	struct SListNode* next;
}SLTNode;

//动态开辟一个链表
SLTNode* BuySLTNode(SLDataType n);

//创建n个链表
SLTNode* CreatSLT(int n);

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

//链表的尾插
void SLTPushBack(SLTNode** pphead, SLDataType n);

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

//单链表的头插
void SLTPushFront(SLTNode** pphead, SLDataType n);

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

//链表的查找
SLTNode* SLTFind(SLTNode* phead, SLDataType n);

//在pos后进行插入
void SLTInsertAfter(SLTNode* pos, SLDataType n);

//在pos前进行插入
void SLTInsertFront(SLTNode** pphead,SLTNode* pos, SLDataType n);

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

//单链表的释放
void SLTDestroy(SLTNode** pphead);

SListNode.c代码

#define _CRT_SECURE_NO_WARNINGS 1
#include"SListNode.h"


//动态开辟一个链表
SLTNode* BuySLTNode(SLDataType n)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = n;
	newnode->next = NULL;
	return newnode;
}

//创建n个链表
SLTNode* CreatSLT(int n)
{
	//这是为了省事，直接用循环创建n个单个链表
	int i = 0;
	//头指针是不能动的，因为最后返回的是链表的头指针
	//所以我们设置一个尾指针，先和头指针相同，移动的
	//时候移动尾指针就好了。
	SLTNode* phead = NULL;
	SLTNode* ptail = NULL;
	for (i = 1; i <= n; i++)
	{
		SLTNode* newnode = BuySLTNode(i);
		//如果头指针是空指针，
		//那么先将头指针和尾指针还有新创建的单个链表设为相等
		if (phead == NULL)
		{
			phead = ptail = newnode;
		}
		else
		{
			ptail->next = newnode;
			ptail = newnode;
		}
	}
	return phead;
}

//打印链表
void PrintSLT(SLTNode* phead)
{
	//我们想一想，如果链表为空可不可以打印
	//很显然是可以的，我们打印一个空指针就很OK
	//所以我们不对他进行断言

	//我们一般不动我们的头指针，
	//所以我们要找一个东西代替他
	SLTNode* cur = phead;
	//我们打印肯定需要循环，是循环就需要条件，
	//我们循环的条件就是
	//直到我们遇到最后一个链表的next了，也就是空指针的时候
	while (cur != NULL)
	{
		printf("%d -> ", cur->data);
		cur = cur->next;
	}
	//因为最后一个肯定是空指针
	//为了打印的美观，我们打印一个空指针
	printf("NULL\n");
	
}

//单链表尾插
void SLTPushBack(SLTNode** pphead,SLDataType n)
{
	SLTNode* newnode = BuySLTNode(n);
	
	if (*pphead == NULL)
	{
		 *pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}
//单链表尾删
void SLTPopBack(SLTNode** pphead)
{
	//如果链表为空，我们就不能再删了
	//需要断言
	assert(*pphead);
	//我们只有一个结点，分类讨论
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//我们在移动的时候一般不移动phead
		//所以我们一般都使用另一个来代替phead
		SLTNode* tail = *pphead;
		//因为我们要将tail的前面的链表找到所以
		//创建一个prev
		SLTNode* prev = NULL;
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		//将prev的next滞空，就相当于删除了
		prev->next = NULL;
	}
	
}
//单链表的头插
void SLTPushFront(SLTNode** pphead, SLDataType n)
{
	SLTNode* newnode = BuySLTNode(n);
	newnode->next = *pphead;
	//头插完，将插完的第一个设为头结点
	*pphead = newnode;
}

//单链表头删
void SLTPopFront(SLTNode** pphead)
{
	//防止空指针的解引用
	assert(*pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

//链表的查找
SLTNode* SLTFind(SLTNode* phead, SLDataType n)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == n)
			return cur;
		else
			cur = cur->next;
	}
	return NULL;
}

//在pos后进行插入
void SLTInsertAfter(SLTNode* pos, SLDataType n)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(n);
	newnode->next = pos->next;
	pos->next = newnode;
}

//在pos前进行插入
void SLTInsertFront(SLTNode** pphead,SLTNode* pos, SLDataType n)
{
	assert(pos);
	
	if (*pphead == pos)
	{
		SLTPushFront(pphead, n);
	}
	else
	{
		SLTNode* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		SLTNode* newnode = BuySLTNode(n);
		cur->next = newnode;
		newnode->next = pos;
	}
}

//删除pos之后
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	//如果pos是最后一个，那么我们还删什们
	//就直接返回就行，不删除
	if (pos->next == NULL)
	{
		return;
	}
	else
	{
		SLTNode* nextNode = pos->next;
		pos->next = nextNode->next;
		free(nextNode);
		//nextNode = NULL;
	}
}
//删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pos);
	//就是头删就直接调用就可以了
	if (*pphead == NULL)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		cur->next = pos->next;
		free(pos);
	}
}

//单链表的释放
void SLTDestroy(SLTNode** pphead)
{
	SLTNode* cur = *pphead;
	//循环一个一个释放
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
}

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

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

相关文章

springcloud之Gateway服务网关

springcloud之Gateway服务网关

1.Gateway服务网关 Spring Cloud Gateway 是 Spring Cloud 的一个全新项目&#xff0c;该项目是基于 Spring 5.0&#xff0c;Spring Boot 2.0 和 Project Reactor 等响应式编程和事件流技术开发的网关&#xff0c;它旨在为微服务架构提供一种简单有效的统一的 API 路由管理方式…
阅读更多...
游戏行业（北区）客户沙龙丨阿里云用户组北京站

游戏行业（北区）客户沙龙丨阿里云用户组北京站

2022 年 8 月 30 日&#xff0c;阿里云在北京举办了第 9 场阿里云用户组&#xff08;AUG&#xff09;活动&#xff0c;活动主题为“游戏行业&#xff08;北区&#xff09;客户沙龙”吸引了众多技术从业者及企业管理者来到现场交流分享。 通过本次活动&#xff0c;参会企业在不同…
阅读更多...
Java探针技术详解

Java探针技术详解

简介 在JVM中运行中&#xff0c;类是通过classLoader加载.class文件进行生成的。在类加载器加载.class文件生成对应的类对象之前时&#xff0c;我们可以通过修改.class文件内容&#xff08;就是字节码修改技术&#xff09;&#xff0c;达到修改类的目的。JDK提供了对字节码进行…
阅读更多...
rhel配置zfs

rhel配置zfs

rhel配置zfs环境声明ZFS简介ZFS块指针的结构ZFS的存储池布局rhel8/rhel9安装zfs始终在启动时加载OpenZFS模块开机自启zfs服务zfs基本操作查看磁盘创建pool和ZFS文件系统创建一个存储池设置zfs挂载点为多个用户创建起始目录向池中添加更多空间修改文件系统名称删除文件系统修改存…
阅读更多...
数据库的存储引擎和事务

数据库的存储引擎和事务

Mysql默认使用INNODB存储引擎 数据库中的各表均被&#xff08;在创建表时&#xff09;指定的存储引擎来处理。 服务器可用的引擎依赖于以下因素&#xff1a;MySql的版本、服务器在开发时如何被配置、启动选项 为了解当前服务器中有哪些存储引擎可用&#xff0c;可使用show e…
阅读更多...
2022 年 项目中常用的工具函数

2022 年 项目中常用的工具函数

目录1. 数字千分位化&#xff0c;支持保留小数点2. 前端生成 uuid3. 传入日期换算出是周几4. 通过计算 text-indent 偏移的负值&#xff0c;实现文字居右隐藏, 右侧对齐 ...text5. 时间格式化函数6. 防抖和节流7. 前端文件流下载8. 后端返回 无格式化时间处理为格式化 20220101…
阅读更多...
回收租赁商城系统功能拆解03讲-商品分类

回收租赁商城系统功能拆解03讲-商品分类

回收租赁系统适用于物品回收、物品租赁、二手买卖交易等三大场景。 可以快速帮助企业搭建类似闲鱼回收/爱回收/爱租机/人人租等回收租赁商城。 回收租赁系统支持智能评估回收价格&#xff0c;后台调整最终回收价&#xff0c;用户同意回收后系统即刻放款&#xff0c;用户微信零…
阅读更多...
【C语言进阶】指针进阶-回调函数

【C语言进阶】指针进阶-回调函数

作者:匿名者Unit 目录一.函数指针数组1.定义2.转移表二.回调函数1.定义2.qsort的使用3.冒泡模拟实现qsort一.函数指针数组 1.定义 在之前我们已经了解过了函数指针: int(*p)(int,int)&add;我们还可以将函数的地址存放在数组&#xff0c;也就是函数指针数组 int (*p[10…
阅读更多...
Qt音视频开发10-ffmpeg内核硬解码

Qt音视频开发10-ffmpeg内核硬解码

一、前言 为了极大的降低CPU的占用&#xff0c;实现硬解码&#xff08;也叫硬件加速&#xff09;非常有必要&#xff0c;一个视频文件或者一路视频流还好&#xff0c;如果增加到64路视频流呢&#xff0c;如果是4K、8K这种高分辨率的视频呢&#xff0c;必须安装上硬解码才是上上…
阅读更多...
初始Spring

初始Spring

初始Spring SSM框架的老大是&#xff1a;Spring大管家&#xff0c;无处不在 Spring是应用了很多优秀的设计模式,对于项目的实现,提供了优秀的解决方案;Spring是一个轻量级(低侵入) 框架.类与类之间的解耦合 IOC控制反转 实现大管家 AOP 增强&#xff0c;面向切面编程&…
阅读更多...
QT—QPalette调色板类

QT—QPalette调色板类

Qt提供的调色板类QPalette专门用于管理部件的外观显示&#xff0c;相当于部件或对话框的调色板&#xff0c;管理他们所有的颜色信息。每个部件都包含一个QPalette对象&#xff0c;在显示时&#xff0c;按照它的QPalette对象中对各部分各状态下的颜色的描述进行绘制。示例点击左…
阅读更多...
C语言-数据的存储-浮点数的存储（8.2）​​​​​​​

C语言-数据的存储-浮点数的存储（8.2）​​​​​​​

目录​​​​​​​ 思维导图&#xff1a; 浮点型在内存中的存储 1.1一个经典的例子 1.2 浮点数存储规则 1.3实践举例 写在最后&#xff1a; 思维导图&#xff1a; 浮点型在内存中的存储 1.1一个经典的例子 #include <stdio.h>int main() {int n 9;//以整形的形式…
阅读更多...
SHELL脚本学习 --- 第七次作业（awk）

SHELL脚本学习 --- 第七次作业（awk）

SHELL脚本学习 — 第七次作业 思路&#xff1a; 1&#xff0c;df -h获取磁盘情况&#xff0c;先用grep过滤出根分区所属行&#xff0c;然后awk打印相应的域 2&#xff0c;首先把多个空格缩成一个&#xff0c;然后用grep找到ens160所属的IP&#xff0c;在awk中使用正则匹配inet…
阅读更多...
C++ STL 容器类和迭代器

C++ STL 容器类和迭代器

一、STL容器类 1.1 STL介绍 容器就是盛放东西的东西&#xff0c;这里被盛放的一般是数据对象&#xff0c;用来盛放的是容器类容器类的内核就是&#xff1a;数据结构 算法STL(Standard Template Library,标准模板库)STL从广义上分为:容器(container)算法(algorithm)迭代器(it…
阅读更多...
在泰国旅居的第5天，我定了两个新目标

在泰国旅居的第5天，我定了两个新目标

点击上方 "大数据肌肉猿"关注, 星标一起成长点击下方链接&#xff0c;进入高质量学习交流群今日更新| 1052个转型案例分享-大数据交流群我在12月14号写了2023年&#xff0c;重新扬帆起航&#xff01;&#xff0c;里面说了2023年开始全球旅居办公&#xff0c;而在元旦…
阅读更多...
历史大讲堂：这是老古董 苹果第一代Macintosh详解

历史大讲堂：这是老古董 苹果第一代Macintosh详解

还记得这个苹果吗&#xff1f;这是美国苹果公司的图标。今天我们就来借着苹果最出名的第一代个人电脑唠一唠苹果的前世今生。 这一代个人电脑 已经有鼠标了&#xff08;右下角&#xff09;&#xff0c;虽然非常的古老 macOS第一代系统就运行在这个上。这里我们也来唠一唠Macin…
阅读更多...
Spring Boot学习笔记（十二）Spring Boot整合Quartz

Spring Boot学习笔记（十二）Spring Boot整合Quartz

一、自定义配置类 不使用springBoot的自动配置类&#xff0c;而是自定义配置类。 1、导入依赖 pom文件&#xff1a; <dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifact…
阅读更多...
Android---Toolbar

Android---Toolbar

目录 Toolbar Toolbar 加上 menu Toolbar 设置 Theme 完整 Demo Toolbar Toolbar 是在 Android 5.0 开始推出的一个 Materal Design 风格的导航控件 &#xff0c;Google 非常推荐大家使用 Toobar 来作为 Android 客户端的导航栏&#xff0c;以此来取代之前的 Actionbar。与 …
阅读更多...
联想昭阳E4电脑U盘安装Win10系统操作教学

联想昭阳E4电脑U盘安装Win10系统操作教学

联想昭阳E4电脑U盘安装Win10系统操作教学分享。有用户想要将自己的联想昭阳E4电脑重装到Win10系统来使用。那么今天教大家一个U盘重装系统的方法&#xff0c;使用这个方法能够在系统出现问题的时候进行系统的重置&#xff0c;解决系统问题。一起来看看具体的重装教学吧。 准备工…
阅读更多...
Exynos_4412——PWM实验

Exynos_4412——PWM实验

目录 一、PWM简介 1.1蜂鸣器工作原理 有源蜂鸣器 无源蜂鸣器 1.2使用GPIO控制 1.3PWM控制 1.4PWM参数 周期​ 占空比 二、Exynos_4412下的PWM控制器 三、PWM寄存器详解 四、PWM编程 一、PWM简介 1.1蜂鸣器工作原理 有源蜂鸣器 有源蜂鸣器只要接上额定电源就可以发…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023