数据结构之单链表(赋源码)

数据结构之单链表

线性表

线性表的顺序存储结构，有着较大的缺陷

  • 插入和删除操作需要移动大量元素。会耗费很多时间
  • 增容需要申请空间，拷贝数据，释放旧空间。会有不小的消耗
  • 即使是使用合理的增容策略，实际上还会浪费许多用不上的空间。如我只需要101个空间存放数据，而100进行2倍增容后有200个空间，这样实际上浪费了99块空间。

线性表的链式存储结构就可以解决这些问题，首先链式存储结构并不需要增容，而是使用多少数据申请多少空间，这一点就避免了时间和空间的浪费。

顺序存储结构和链式存储结构

存储方式
  • 顺序存储结构，使用一段连续的空间依次存储数据
  • 链式存储结构，使用一个个存储单元存放数据
时间性能

  • 插入和删除

    • 顺序存储结构，O(N)

    • 链式存储结构，O(1)

空间性能
  • 顺序存储结构，需要预分配空间，给小了不够用，给打了浪费
  • 链式存储结构，不需要预分配空间，只要有新的元素插入才会开辟内存单元

使用场景

具体在什么场景使用不同的线性表存储结构呢？

  • 若线性表需要频繁的查找，很少进行插入和删除操作时，可以采用顺序存储结构。

  • 若线性表中的元素个数变化较大或不知道有多大时，可以采用链式存储结构。

    • 单链表在插入和删除不需要移动元素，只需改变指针的指向即可。

单链表

概念：单链表是在物理存储结构上不连续，逻辑结构上连续的线性表。它是通过指针链接，就像火车的一节一节车厢一样通过挂钩链接在一起，车厢就是单链表的一个一个节点，里面用来存放数据。

而在单链表里“车厢”内有些什么的呢？单链表是一种数据结构“车厢”里肯定存放在数据，而单链表又是通过指针链接在以起，就像车厢的钩子一样链接，它在物理存储结构上不是连续的，所以“车厢”里还有一个指针变量用来存放下一节“车厢”的地址。

在这里插入图片描述

typedef int SLNodeDatatpye;
struct SListNode
{
	SLNodeDatatpye data;//存放数据
	struct SListNode* next;//存放单链表类型的指针
};

存放的数据类型：单链表不会只用来存放整形数据，这里只是以整形举例，所以需要对类型重命名，方便对后面的类型进行修改，需要修改数据类型的只需要动动 typedef int SLNodeDatatpye;，这串代码。

在这里插入图片描述

功能实现

typedef int SLNodeDatatpye;
struct SListNode
{
	SLNodeDatatpye data;
	struct SListNode* next;
};
typedef struct SListNode SL;

//创建节点
SL* SLBuyNode(SLNodeDatatpye x);

//打印
void SLPrint(SL** pphead);

//头插
void SLPushFront(SL** pphead, SLNodeDatatpye x);
//尾插
void SLPushBack(SL** pphead, SLNodeDatatpye x);

//头删
void SLPopFront(SL** pphead);
//尾删
void SLPopBack(SL** pphead);

//查找，返回地址
SL* SLFind(SL** pphead, SLNodeDatatpye x);

//指定位置插入(之前)
void SLInsert(SL** pphead, SLNodeDatatpye x, SL* pos);

//删除pos之后的节点
void SLEraseBack(SL* pos);
//删除pos节点
void SLErase(SL** pphead, SL* pos);

//销毁链表
void SLDestory(SL** pphead);

创建节点和打印

实现单链表的功能第一步需要为它创建节点以用来存放数据。实现打印功能，将链表的数据打印出来方便更好的观查链表存储数据的情况，配合着调试功能可以更加完善的查找，观测在实现完一个功能，它执行的结果是否与预期相符合，若发生错误，又可以借助调试功能更好、更快的查找bug。

//创建节点
SL* SLBuyNode(SLNodeDatatpye x)
{
	SL* newnode = (SL*)malloc(sizeof(SL));
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;//忘记返回newnode的地址了
}
//打印
void SLPrint(SL** phead)
{
	//assert(phead);
	SL* pcur = phead;
	while (pcur)//pcur != NULL
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

创建节点很容易理解，一个单链表的节点用来存放数据和下一个节点的地址，在创建节点时使用malloc函数开辟一个内存单元，然后判断开辟空间是否成功，接着将传递过来的参数放在 newnode->data = x;里。

newnode->next = NULL;置为空即可，这只是一个节点没有与其余节点有任何关联，借助插入函数来实现像火车一样一节一节车厢链接在一起的效果。

打印单链表时应注意：

循环体，单链表的循环通过next指针来实现，结束条件是最后一个节点的next指针为空。

pcur = pcur->next;，通过 pcur->next，赋值给 pcur，来来遍历每一个节点。重述：将pcur的下一个节点的地址赋给pcur，此时pcur就等于下一个节点，直达循环到最后一个节点，在最后一个节点data == 4 ，pcur = pcur->next;，为空指针将其赋给 pcur，此时它为空指针，跳出循环。

在这里插入图片描述

查找数据

查找数据，为什么传递二级指针，这里是为了保持函数接口的一致性，后续实现的插入、删除、销毁操作都需要传递二级指针，同时也是减少对函数的混淆，当函数量较多时，这个函数传一级指针，另一个函数传递二级指针，四处分散，容易让使用者看了傻眼~。

//查找，返回地址
SL* SLFind(SL** pphead, SLNodeDatatpye x)
{
	assert(*pphead && pphead);
	SL* pcur = *pphead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

查找数据的基本的逻辑与打印类似，都需要使用循环遍历链表， 循环内增加了一个条件判断，用于判断这个节点的数据是否等于形参x，相等就说明找到了 “找到了”，将当前节点的地址返回即可，若跳出循环后还是没有找到对应的节点，将返回NULL，空指针。

assert断言是防止，传递过来的链表的节点是空指针，在函数内对进行解引用导致程序报错。

插入数据

在插入数据时需要考虑，插入的数据会对影响那些节点

特别注意的一点，插入数据会对单链表进行改变，在传递参数的时候需要对取pliat的地址，而plist又是一个指针变量，所以函数需要使用二级指针来接收。

节点函数参数
*plist(第一个节点)**pphead
plist(指向第一个节点的指针)*pphead
&plist(指向第一个节点的指针的地址)pphead
void test()
{
	SL* plist = NULL;
	SLPushFront(&plist, 1);
	SLPushFront(&plist, 2);
}

//头插
void SLPushFront(SL** pphead, SLNodeDatatpye x)
{
	assert(pphead);
	SL* newnode = SLBuyNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}
//尾插
void SLPushBack(SL** pphead, SLNodeDatatpye x)
{
	assert(pphead);
	if (*pphead == NULL)
	{
		*pphead = SLBuyNode(x);
	}
	else
	{
		SL* pcur = *pphead;
		while (pcur->next)
		{
			pcur = pcur->next;
		}
		pcur->next = SLBuyNode(x);
	}
}

需要对头插、尾插分两种场景，一是没有节点，传递过来的是空链表，二是有节点，传递的不是空链表。

实现头插、尾插先认为传递的不是一个空链表，基于此来实现，然后对空链表的情况做出判断和处理。这样做会更容易上手，先实现最主要的功能，然后再检擦其完整性。

assert断言是防止，传递过来的链表的节点是空指针，在函数内对进行解引用导致程序报错。

头插：

  1. 需要创建一个节点，SL* newnode = SLBuyNode(x);，使用上述的函数创建一个新节点
  2. 将其放在链表的第一个位置，newnode->next = *pphead;，

在这里插入图片描述

  1. 将新插入的节点置为新的头(让*pphead指向新的节点)，*pphead = newnode;。

在这里插入图片描述

千万别忘了，需要将*pphead置为新的头，否则此时，它指向的是下一个节点的位置，会影响到后续对链表的操作。

**最后取特殊情况：**当链表为空时，上述头插是否支持。很明显，我们将 *pphead == NULL的情况带入头插函数，SL* newnode = SLBuyNode(x);，第一步正常创建节点；newnode->next = *pphead;，第二步正常，由于只有一个节点所以 newnode->next == NULL，没有问题；*pphead = newnode;，第三步将*pphead置为新的头，这步没有问题，也不存在对空指针解引用的情况。

最后通过运行代码观测：

在这里插入图片描述

尾插：

尾插同理，也是将链表默认不为空的情况实现。

  • 想要进行尾插首先得有一个指针指向最后一个节点，然后将创建的新节点插入。
  • 定义一个指针pcur，使用循环遍历到最后一个节点。
  • 跳出循环，完成最后一步尾插代码~，pcur->next = SLBuyNode(x);。

当链表为空时，这不就是头插吗？！，这样我们使用一个if语句判断*pphead是否为空，为空就调用头插函数，不为空就循环到最后一个节点，然后插入~

指定位置插入：

指定位置插入实际上与尾插代码差别不大，就改变了跳出while循环的的条件。

//指定位置插入(之前)
void SLInsert(SL** pphead, SLNodeDatatpye x, SL* pos)
{
	assert(pphead);
	assert(pos);
	SL* newnode = SLBuyNode(x);
	SL* pcur = *pphead;
	if (*pphead == pos)//这不就是头插吗？
	{
		newnode->next = pos;
		*pphead = newnode;
	}
	else
	{
		while (pcur->next != pos)
		{
			pcur = pcur->next;
		}
		pcur->next = newnode;
		newnode->next = pos;

	}
}

首先想要实现指定位置插入，传入的链表和pos不可能为空使用一个assert断言进行判断。

同样，将指定位置插入分为两种情况，一是 *pphead == pos ，二是 *pphead ！= pos

这里可以将pos看似空指针（NULL），那指定位置插入（之前）不就是尾插吗？细节上不就是在 pos这个指针上，处理它也很简单。

在指针pos之前插入数据会影响到的节点：pcur pos ，在pcur和pos之前插入newnode，pcur newnode pos

在这里插入图片描述

这里需要将pcur和pos之间的”线“断开，然后使 newnode->next = pos;，newnode->next = pos;这不就完成了插入操作。
在这里插入图片描述

删除数据

在删除数据时需要考虑，删除这个节点会影响到那些节点

删除数据需要注意的是 *pphead 和 pphead不能为空，删除数据也不可能删除空，函数里对空指针解引用也会报错。

头删：

头删的逻辑简单：一，保存*pphead之后的节点 SL* pcur = (*pphead)->next;，二、然后释放第一个节点 free(*pphead);，三、最后将 pcur 赋给 *pphead，更新头节点的位置。

尾删：

尾删，需要考虑最后一个节点，和最后一个节点之前的节点，所以需要使用pdst指针指向倒数第二个节点，以及pcur指针指向最后一个节点。在循环时以 pcur->next != NULL为结束条件，在循环体内要保证 pdst指针在pcur指针后，这种做法保证了，pdst指针在pcur指针后，而pcur指针指向的也是最后一个节点。

SL* pdst = *pphead; SL* pcur = pdst->next;
在这里插入图片描述

在这里插入图片描述

//头删
void SLPopFront(SL** pphead)
{
	assert(*pphead && pphead);
	SL* pcur = (*pphead)->next;
	free(*pphead);
	*pphead = pcur;
}
//尾删
void SLPopBack(SL** pphead)
{
	assert(*pphead && pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SL* pdst = *pphead;
		SL* pcur = pdst->next;
		while (pcur->next)
		{
			pcur = pcur->next;
			pdst = pdst->next;
		}
		pdst->next = NULL;
		free(pcur);
		pcur = NULL;
	}
}

指定位置删除数据：

指定位置删除数据与指定位置插入数据类似，与尾删也比较类似。首先想要指定位置删除数据， *pphead和pphead以及pos都不可能为空，否则这还删什么?传递过来的东西都是空的。

删除指定位置的数据时需要从它会影响那些节点，pos会影响到 pcur pos pos->next。
在这里插入图片描述

*pphead 刚好等于pos 的情况，和 *pphead != pos的情况。当 *pphead != pos时：

  • 需要使用循环将定义的pcur指针指向pos之前的节点，所以结束条件是 pcur->next != pos

  • 当跳出循环时开始销毁，在销毁前需要将 pos->next;赋给 pcur->next，否则直接删除pos节点，无法将pso的后继节点与它前驱节点链接，链表断开了~

    在这里插入图片描述

  • 讲pcur与pos->next链接上后，释放pos即可。

当*pphead == pos时，pos指向的时第一个节点的位置，此时不就是头删吗，这是直接调用头删函数就完成了。

//指定位置删除
void SLErase(SL** pphead, SL* pos)
{
	assert(*pphead && pphead);
	assert(pos);
    SL* pcur = *pphead;
	if (*pphead == pos)//头删
	{
		//free(*pphead);
		//*pphead = NULL;
		SLPopFront(pphead);
	}
	else
	{
		while (pcur->next != pos)
		{
			pcur = pcur->next;
		}
		pcur->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
//删除pos之后的节点
void SLEraseBack(SL* pos)
{
	assert(pos->next && pos);
	//  pos pos->next pos->next-->next
	SL* del = pos->next;
	//  pos del del->next
	pos->next = del->next;
	free(del);
	del = NULL;
}

删除pos之后的节点逻辑简单与删除pos节点类似。第一步同样是需要考虑，删除pos之后·的节点会影响到那些节点。

删除pos之后的节点会影响 ：pos pos->next pos->next-->next，这三个节点，所以传递过来的 pos 和 pos->next不能为空否则就是对空指针解引用，导致程序异常。

在删除时，需要注意删除和将pos 与 pos->next–>next链接的顺序， 先链接，在删除

  • 将pos->next保存，赋给del指针
  • 将pos与 del->next链接
  • 释放del指针

销毁链表

销毁链表需要使用free对每一个节点进行释放。
在这里插入图片描述

//销毁链表
void SLDestory(SL** pphead)
{
	//循环销毁所有节点
	assert(*pphead && pphead);
	SL* pcur = *pphead;
	while (pcur)
	{
		SL* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

销毁链表，需要对每一个节点进行释放，而只使用一个指针pcur，释放当前的节点就找不到下一个节点了，这里需要使用两个指针。

一个指针用来释放（pcur），一个指针用来指向待释放之后的节点（next）。

在这里插入图片描述

当释放完pcur节点后，更新pcur的位置 pcur = next;，用来释放下一个节点，next指针也需要更新用来指向下一个节点 next = pcur->next;，用来对pcur进行更新。直到pcur指向空指针时释放完所有节点，跳出循环。而 *pphead，还没有置为空，这时候时野指针，最后一步 *pphead = NULL;。

源码

SListNode.h

#pragma once

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


typedef int SLNodeDatatpye;
struct SListNode
{
	SLNodeDatatpye data;
	struct SListNode* next;
};
typedef struct SListNode SL;

//创建节点
SL* SLBuyNode(SLNodeDatatpye x);

//打印
void SLPrint(SL* phead);

//头插
void SLPushFront(SL** pphead, SLNodeDatatpye x);
//尾插
void SLPushBack(SL** pphead, SLNodeDatatpye x);

//头删
void SLPopFront(SL** pphead);
//尾删
void SLPopBack(SL** pphead);

//查找，返回地址
SL* SLFind(SL** pphead, SLNodeDatatpye x);//不需要二级指针，保证接口一直，所以传递二级

//指定位置插入(之前)
void SLInsert(SL** pphead, SLNodeDatatpye x, SL* pos);

//删除pos之后的节点
void SLEraseBack(SL* pos);
//删除pos节点
void SLErase(SL** pphead, SL* pos);

//销毁链表
void SLDestory(SL** pphead);

SListNode.c

#define _CRT_SECURE_NO_WARNINGS

#include "SListNode.h"
//创建节点
SL* SLBuyNode(SLNodeDatatpye x)
{
	SL* newnode = (SL*)malloc(sizeof(SL));
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

//打印
void SLPrint(SL* phead)
{
	//assert(phead);
	SL* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

//头插
void SLPushFront(SL** pphead, SLNodeDatatpye x)
{
	assert(pphead);
		SL* newnode = SLBuyNode(x);
		newnode->next = *pphead;
		*pphead = newnode;
}
//尾插
void SLPushBack(SL** pphead, SLNodeDatatpye x)
{
	assert(pphead);
	if (*pphead == NULL)
	{
		*pphead = SLBuyNode(x);
	}
	else
	{
		SL* pcur = *pphead;
		while (pcur->next)
		{
			pcur = pcur->next;
		}
		pcur->next = SLBuyNode(x);
	}
}
//头删
void SLPopFront(SL** pphead)
{
	assert(*pphead && pphead);
	SL* pcur = (*pphead)->next;
	free(*pphead);
	*pphead = pcur;
}
//尾删
void SLPopBack(SL** pphead)
{
	assert(*pphead && pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SL* pdst = *pphead;
		SL* pcur = pdst->next;
		while (pcur->next)
		{
			pcur = pcur->next;
			pdst = pdst->next;
		}
		pdst->next = NULL;
		free(pcur);
		pcur = NULL;
	}
}
//查找，返回地址
SL* SLFind(SL** pphead, SLNodeDatatpye x)
{
	assert(*pphead && pphead);
	SL* pcur = *pphead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}
//指定位置插入(之前)
void SLInsert(SL** pphead, SLNodeDatatpye x, SL* pos)
{
	assert(pphead);
	assert(pos);
	SL* newnode = SLBuyNode(x);
	SL* pcur = *pphead;
	if (*pphead == pos)
	{
		newnode->next = pos;
		*pphead = newnode;
	}
	else
	{
		while (pcur->next != pos)
		{
			pcur = pcur->next;
		}
		pcur->next = newnode;
		newnode->next = pos;

	}
}
//指定位置删除
void SLErase(SL** pphead, SL* pos)
{
	assert(*pphead && pphead);
	assert(pos);
	if (*pphead == pos)//头删
	{
		//free(*pphead);
		//*pphead = NULL;
		SLPopFront(pphead);
	}
	else
	{
		SL* pcur = *pphead;
		while (pcur->next != pos)
		{
			pcur = pcur->next;
		}
		pcur->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
//删除pos之后的节点
void SLEraseBack(SL* pos)
{
	assert(pos->next && pos);

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

//销毁链表
void SLDestory(SL** pphead)
{
	assert(*pphead && pphead);

	SL* pcur = *pphead;
	while (pcur)
	{
		SL* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

语言模型演进：从NLP到LLM的跨越之旅

语言模型演进：从NLP到LLM的跨越之旅

在人工智能的浩瀚宇宙中&#xff0c;自然语言处理&#xff08;NLP&#xff09;一直是一个充满挑战和机遇的领域。随着技术的发展&#xff0c;我们见证了从传统规则到统计机器学习&#xff0c;再到深度学习和预训练模型的演进。如今&#xff0c;我们站在了大型语言模型&#xff…
阅读更多...
木舟0基础学习Java的第十六天(异常，分类，自定义异常，注意事项)

木舟0基础学习Java的第十六天(异常，分类，自定义异常，注意事项)

异常 异常概述&#xff1a;异常是Java程序运行过程中出现的错误 异常分类&#xff1a;API查找Throwable 1.Error(服务器宕机&#xff0c;数据库崩溃等) 2.Exception C(异常的继承体系)API查RuntimeException 运行时异常&#xff1a;一般是程序员的错误异常可以让我们发现错…
阅读更多...
C#实现最短路径算法

C#实现最短路径算法

创建点集 double r 200 * 500;double width 1920;double height 1080;int col (int)(r / width);int row (int)(r / height);List<(double, double)> list1 new List<(double, double)>();for (int i 0; i < row; i){var y i * height;if (y < r){va…
阅读更多...
青年发展型城市成新青择地，期待与挑战并存

青年发展型城市成新青择地，期待与挑战并存

随着社会的发展和城市化进程的加快&#xff0c;青年人在选择未来定居地时面临着越来越多的选择。近日&#xff0c;中国青年报社社会调查中心联合问卷网对1500名青年进行的一项调查显示&#xff0c;74.8%的受访青年表示会优先考虑青年发展型城市。那么&#xff0c;青年在选择未来…
阅读更多...
编程范式之并发编程

编程范式之并发编程

目录 前言1. 并发编程的定义2. 并发编程的特点2.1 任务交替执行2.2 状态共享与同步2.3 并行执行 3. 并发编程的适用场景3.1 高性能计算3.2 I/O 密集型应用3.3 实时系统 4. 并发编程的优点4.1 提高资源利用率4.2 缩短响应时间4.3 提高系统吞吐量 5. 并发编程的缺点5.1 编程复杂性…
阅读更多...
gpt-4o看图说话-根据图片回答问题

gpt-4o看图说话-根据图片回答问题

问题&#xff1a;中国的人口老龄化究竟有多严重&#xff1f; 代码下实现如下&#xff1a;&#xff08;直接调用openai的chat接口&#xff09; import os import base64 import requests def encode_image(image_path): """ 对图片文件进行 Base64 编码 输入…
阅读更多...
微分方程建模

微分方程建模

微分方程建模是数学建模的重要方法&#xff0c;因为许多实际问题的数学描述将导致求解微分方程的定解问题。在高教杯数学建模竞赛中每年都会有一道微分方程建模问题&#xff0c;大体上可以按以 下几步&#xff1a; 1. 根据实际要求确定要研究的量(自变量、未知函数、必要的参数…
阅读更多...
【Linux信号】阻塞信号、信号在内核中的表示、信号集操作函数、sigprocmask、sigpending

【Linux信号】阻塞信号、信号在内核中的表示、信号集操作函数、sigprocmask、sigpending

我们先来了解一下关于信号的一些常见概念&#xff1a; 实际执行 信号的处理动作 称为信号递达。 信号从产生到递达的之间的状态称为信号未决。 进程可以选择阻塞(Block)某个信号。 被阻塞的信号产生时是处于未决状态的&#xff0c;知道进程解除对该信号的阻塞&#xff0c;该…
阅读更多...
基于颜色模型和边缘检测的火焰识别FPGA实现,包含testbench和matlab验证程序

基于颜色模型和边缘检测的火焰识别FPGA实现,包含testbench和matlab验证程序

目录 1.算法运行效果图预览 2.算法运行软件版本 3.部分核心程序 4.算法理论概述 5.算法完整程序工程 1.算法运行效果图预览 (完整程序运行后无水印) 将FPGA仿真结果导入到matlab显示结果&#xff1a; 测试样本1 测试样本2 测试样本3 2.算法运行软件版本 vivado2019.2 …
阅读更多...
鸿蒙HarmonyOS应用开发为何选择ArkTS不是Java？

鸿蒙HarmonyOS应用开发为何选择ArkTS不是Java？

前言 随着智能设备的快速发展&#xff0c;操作系统的需求也变得越来越多样化。为了满足不同设备的需求&#xff0c;华为推出了鸿蒙HarmonyOS。 与传统的操作系统不同&#xff0c;HarmonyOS采用了一种新的开发语言——ArkTS。 但是&#xff0c;刚推出鸿蒙系统的时候&#xff0…
阅读更多...
MySQL数据库课程设计——订餐系统（MySQL数据库+Qt5用户界面+python）

MySQL数据库课程设计——订餐系统（MySQL数据库+Qt5用户界面+python）

目录 一、系统定义 二、需求分析 三、系统设计 四、详细设计 五、参考文献 一、系统定义 订餐系统是一种基于网络技术的在线点餐平台&#xff0c;旨在为用户提供方便快捷的订餐服务。该系统主要包括用户登录、用户管理、菜单管理、订单管理、支付管理、评价管理等功能模块…
阅读更多...
云服务器重置密码后，xshell远程连接不上，重新启用密码登录方式

云服务器重置密码后，xshell远程连接不上，重新启用密码登录方式

云服务器重置密码后 &#xff0c;xshell连接出现不能使用密码登录 解决方案&#xff1a;以下来自阿里云重新启用密码登录方式帮助文档 为轻量应用服务器创建密钥且重启服务器使密钥生效后&#xff0c;服务器会自动禁止使用root用户及密码登录。如果您需要重新启用密码登录方式&…
阅读更多...
比特币交易繁忙的一天

比特币交易繁忙的一天

早晨：市场开盘与准备工作 6:00 AM - 全球市场监测 交易员们早早起床，开始监测全球市场动态，尤其是亚洲市场的动向。通过查看新闻、分析报告和市场数据，了解可能影响比特币价格的因素。 7:00 AM - 团队会议 召开晨会，讨论当天的交易策略。团队分析前一天的交易情况，评…
阅读更多...
OpenGL笔记五之VBO与VAO

OpenGL笔记五之VBO与VAO

OpenGL笔记五之VBO与VAO 总结自bilibili赵新政老师的教程 code review! 文章目录 OpenGL笔记五之VBO与VAO1.VBO2.VAO3.VBO与VAO对比 1.VBO 代码 void prepareVBO() {//1 创建一个vbo *******还没有真正分配显存*********GLuint vbo 0;GL_CALL(glGenBuffers(1, &vbo))…
阅读更多...
适合创业公司使用的wordpress主题

适合创业公司使用的wordpress主题

对于创业公司来说&#xff0c;‌选择一个适合的WordPress主题至关重要&#xff0c;‌它不仅能够提升公司网站的外观和用户体验&#xff0c;‌还能帮助优化搜索引擎排名&#xff0c;‌从而吸引更多的潜在客户。‌以下是一些推荐的WordPress主题&#xff0c;‌特别适合创业公司使…
阅读更多...
人工智能算法工程师(中级)课程2-Opencv视觉处理之高级操作与代码详解

人工智能算法工程师(中级)课程2-Opencv视觉处理之高级操作与代码详解

大家好&#xff0c;我是微学AI&#xff0c;今天给大家介绍一下人工智能算法工程师(中级)课程2-Opencv视觉处理之高级操作与代码详解。在上一节课中的OpenCV基础操作我们了解到OpenCV是一个开源的计算机视觉软件库。它提供了各种视觉处理函数&#xff0c;并支持多种编程语言&…
阅读更多...
传感器标定（三）激光雷达外参标定（lidar2ins）

传感器标定（三）激光雷达外参标定（lidar2ins）

一、数据采集 1、LiDAR 传感器的 LiDAR PCD 数据 2、来自 IMU 传感器的姿势文件 3、手动测量传感器之间外部参数初始值并写入的 JSON 文件 二、下载标定工具 //总的git地址&#xff1a; https://github.com/PJLab-ADG/SensorsCalibration git地址&#xff1a; https://githu…
阅读更多...
扩散基生物打印：打造多材料组织构建的新篇章

扩散基生物打印：打造多材料组织构建的新篇章

生物打印技术正在经历快速发展&#xff0c;而扩散基生物打印作为一种新兴策略&#xff0c;为制造更复杂和功能化的组织构建物提供了新的可能性。这种方法利用扩散原理&#xff0c;通过在不同区域之间扩散酶、交联剂或可交联聚合物来促进交联&#xff0c;从而实现多种材料的集成…
阅读更多...
【论文阅读笔记】ASPS: Augmented Segment Anything Model for Polyp Segmentation

【论文阅读笔记】ASPS: Augmented Segment Anything Model for Polyp Segmentation

1.论文介绍 ASPS: Augmented Segment Anything Model for Polyp Segmentation ASPS&#xff1a;用于息肉分割的扩展SAM模型 2024年 arxiv Paper Code 2.摘要 息肉分割在结直肠癌诊断中起着至关重要的作用。最近&#xff0c;Segment Anything Model(SAM)的出现利用其在大规模…
阅读更多...
软件缺陷简介

软件缺陷简介

缺陷种类 遗漏&#xff0c;指规定或预期的需求为体现在产品种错误&#xff0c;需求是明确的&#xff0c;在实现阶段未将需求的功能正确实现冗余&#xff0c;需求说明文档中未涉及的需求被实现了不满意&#xff0c;用户对产品的实现不满意也成为缺陷 缺陷等级划分 致命&#…
阅读更多...
最新文章

Copyright @ 2022~2023