＜数据结构与算法＞单链表

原创 已于 2023-03-25 22:47:48 修改 · 252 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c语言 #数据结构 #算法

于 2023-03-20 08:48:09 首次发布
本文详细介绍了链表的基本概念、结构以及如何实现链表的插入、删除、打印等操作。通过示例代码展示了链表的头插、尾插、查找、前插入、删除、后插入和后删除等功能，并提供了完整代码实现。同时，文中强调了在处理链表时需要注意的指针管理和内存分配问题。

 

 

目录

前言

一、链表的概念及结构

二、链表各函数的实现

结构体定义 

SLTPrint  打印

SLTPushBack 尾插

 SLTPushFront 头插

 SLTPopBack 尾删

SLTPopFront  头删

SListFind 查找

 SListInsert 前插入

 SLTErase 删除

SLTInsertAfter 后插入

SLTEraseAfter 后删除

SLTDestroy 释放 

三、完整链表代码

1.SList.h 

2.SList.c

3. Test.c

总结

前言

由顺序表的问题及思考，我们又有了链表这一概念。

一、链表的概念及结构

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

 

二、链表各函数的实现

结构体定义 

  •  在定义结构体时，struct SListNode才是结构体类型名，在未完成重命名操作前，不能使用重命名后的名字
typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;//在定义结构体时，struct SListNode才是结构体类型名，在未完成重命名操作前，不能使用重命名后的名字
}SLTNode;

SLTPrint  打印

  • 不要看到指针就断言，这里的打印函数不需要assert断言，因为链表的数据是存放在结构体中的，为空同样可以打印，而之前学过的顺序表打印时则需要断言，这是因为它的数据不是存放在结构体中的，而是存放在一个数组空间，该结构体是必须存在的，由结构体内的指针存放该空间的地址，结构体内有指向数组的指针、size、capacity，如果不断言，那么就可能出现错误（数组内容是否为空是由size决定的）
  • 遍历链表时，不能使用指针++，因为链表内每个节点都是单独malloc出来的，地址是不连续的，如果整个空间都是连续的那么指针++就可以跳过一个结构体大小的字节，就可以实现遍历。
  • 循环条件不能为cur -> next != NULL 因为这样会丢掉最后一个数据 
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");
}

SLTPushBack 尾插

  • 首先开辟新节点，强转为结构体指针类型，并判断是否成功开辟
  • 如果链表不为空，寻找尾节点，该节点的next指针指向NULL，循环条件不能写为 tail != NULL 因为这样循环会使tail指向到NULL，应为tail -> next != NULL
  • 找到后不能写为 tail = newnode 因为tail只是一个局部变量，将新节点地址赋值给tail毫无用处，tail销毁后什么也没有改变，实际上应为 tail ->next  = newnode 这样赋值才是真正的串联起尾节点与新插入的节点，将新节点的地址赋值给上一个节点的next 
  • 尾插本质：原尾节点中要储存新尾节点的地址
  • 如果链表为空，即phead == NULL 那么就把新开辟的节点赋值给 phead，但是一定要注意，我们在主函数中会创建 SLTNode * plist == NULL，把它作为头节点，如果要改变plist指针的值，我们要传该指针的地址！即二级指针。
  • 但是在后面要改变结构体内的next指针进行链接时，不需要再使用二级指针，因为我们要改变是结构体，使用结构体指针即可

例如:

void Func(int* ptr)
{
    ptr = (int* )malloc(sizeof(int));
}

int main()
{
    int *px = NULL;
    Func(px);
    return 0;
}

对ptr开辟空间不会改变px的值 

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;
	}
}

 SLTPushFront 头插

  • 头插依旧需要传二级指针，因为必有一种情况（链表为空）需要改变头节点的值。
  • 链表为空或不为空，头插操作一样
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

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

 SLTPopBack 尾删

  • 删除时要找到尾的上一个节点，将该节点的next 赋值为NULL，不能直接将尾节点释放，这样的话会使倒数第二个指针成为野指针
  • 若只有一个数据，上面程序就不适合了，需要单独讨论，释放头节点并置为空
  • 若没有数据，温柔/暴力检查

 

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;
	}
}

SLTPopFront  头删

  • 只用分为俩种情况，大于等于一个数据、没有数据
  • 创建新的结构体指针first，用于存储第一个结构体，在释放第一个结构体空间时，释放first即可，不能释放pphead

void SLTPopFront(SLTNode** pphead)
{
	// 暴力检查
	assert(pphead);
	assert(*pphead);

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

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

SListFind 查找

  • 定义结构体指针，遍历链表，找到值与给定的相等的节点，并返回该节点地址
  • 修改链表中某节点的值一般都要使用查找函数
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}

		cur = cur->next;
	}

	return NULL;
}

 SListInsert 前插入

  • 如果要插入的位置是第一个时，就是头插（在某位置插入，是在该位置之前，所以不可能尾插）
  • 否则，就找到该节点的上一个节点，进行插入操作
  • 二级指针pphead必不为空，因为它的值是一级指针plist的地址，一般情况下它是不为空的，但是以防万一有错误的传参，所以要断言。
  • 要找的结构体指针pos也不能为空，这样会导致找不到该节点，所以也需要断言。

是否断言需要分析：

  • 空链表可以打印，不需要断言链表指针
  • 空链表可以插入，不需要断言链表指针
  • 空链表不能删除，需要断言链表指针
// 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;
	}
}

 SLTErase 删除

  • 首先要断言pphead和pos，又因为断言pos的同时，间接的断言了链表不为空，所以可以不用断言 *pphead，但是为了代码更健壮，我们加上 *pphead 的断言
  • free后再本函数内置空没有用，因为此时形参改变不了实参的值，所以可以让使用者再外面使用删除函数后自己置空，也可以传二级指针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;
	}
}

SLTInsertAfter 后插入

  • 创建新节点
  • 插入赋值操作，注意交换顺序，避免节点自我链接导致死循环
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

SLTEraseAfter 后删除

  • 断言该节点的下一节点是否为空
  • 如果使用pos->next = pos->next->next方法需要提前记录要删除的那个节点，避免内存泄漏
// 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;
}

SLTDestroy 释放 

  • 节点释放后，结构体指针还是指向该节点的，但是节点释放后，该空间已归还操作系统，里面的值是随机的，再次使用该节点赋值会造成野指针情况

注意，下面这种形式代码是错误的，是对指针的认识不正确造成的，可以画图理解

void SLTDestroy(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur)
	{
		SLTNode* tmp = cur;
		free(cur);
		//cur = cur->next;  野指针
		cur = tmp->next; //同样错误，没区别
	}
}

正确代码：

void SLTDestroy(SLTNode** pphead)
{
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* tmp = cur->next;
		free(cur);
		//cur = cur->next;  野指针
		cur = tmp; //同样错误，没区别
	}
    //phead = NULL;  这里置空是没用的，改变不了phead的值，可以让使用者外部置空
    *pphead = NULL;
}

三、完整链表代码

1.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;

//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);
//
void SLTEraseAfter(SLTNode* pos);

void SLTDestroy(SLTNode** phead);

2.SList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"

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;
}

//释放
void SLTDestroy(SLTNode** pphead)
{
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* tmp = cur->next;
		free(cur);
		//cur = cur->next;  野指针
		cur = tmp; //同样错误，没区别
	}
    //phead = NULL;  这里置空是没用的，改变不了phead的值，可以让使用者外部置空
    *pphead = NULL;
}

3. Test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

void TestSList1()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);

	SLTPrint(plist);
}

void TestSList2()
{
	SLTNode* plist = NULL;
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);

	SLTPopBack(&plist);
	SLTPrint(plist);

	SLTPopBack(&plist);
	SLTPrint(plist);

	SLTPopBack(&plist);
	SLTPrint(plist);

	SLTPopBack(&plist);
	SLTPrint(plist);
}

void TestSList3()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	SLTPopFront(&plist);
	SLTPrint(plist);

	SLTPopFront(&plist);
	SLTPrint(plist);

	SLTPopFront(&plist);
	SLTPrint(plist);

	SLTPopFront(&plist);
	SLTPrint(plist);
}

int main()
{
	TestSList3();

	return 0;
}

//void Func(int y)
//{
//	y = 1;
//}

//void Func(int* p)
//{
//	*p = 1;
//}
//
//int main()
//{
//	int x = 0;
//	Func(&x);
//
//	return 0;
//}

//void Func(int* ptr)
//{
//	ptr = (int*)malloc(sizeof(int));
//}
//
//int main()
//{
//	int* px = NULL;
//	Func(px);
//  free(px);
// 
//
//	return 0;
//}

//void Func(int** pptr)
//{
//	*pptr = (int*)malloc(sizeof(int));
//}
//
//int main()
//{
//	int* px = NULL;
//	Func(&px);
//
//	free(px);
//
//	return 0;
//}

总结

        熟记其中各函数定义时的小细节以防出错，此外还可自行编写菜单功能方便使用者使用。

以上就是今天要讲的内容，本文仅仅简单介绍了单链表如何编写以及其中的小小细节，要掌握单链表还要多多理解记忆与练习。

        下一节，小帅会带大家一起练习单链表的各种经典习题。最后，如果小帅的本文哪里有错误，还请大家指出，请在评论区留言（ps：抱大佬的腿），新手创作，实属不易，如果满意，还请给个免费的赞，三连也不是不可以（流口水幻想）嘿！那我们下期再见喽，拜拜！

 

单链表的基本实现
m0_62537611的博客
05-20 494
前言 上一篇文章中我们学习了顺序表​​​​​​【数据结构】——顺序表的基本实现_爱偷懒的猫(๑>؂<๑）的博客-优快云博客 顺序表是用数组实现的，优势是：物理空间连续并且支持下标随机访问 劣势是：1、空间不够，需要扩容。但是扩容有一定的性能消耗，其次一般扩容2倍，存在一些空间浪费。 ​​​​​2、头部和中间位置插入删除效率低下 链表正好可以解决这些劣势 文章目录 一、单链表的的概念和结构 二、单链表的接口实现 三、完整代码 一、单链表的概念和结构 概念：链表是一..
数据结构之链表2
m0_61567378的博客
11-03 540
实现链表的头插 test.c #define _CRT_SECURE_NO_WARNINGS 1 #include"slist.h" //链表的概念及结构 //链表是一种物理存储结构上非连续，非顺序的存储结构，数据元素的逻辑结构是通过链表中的指针来链接 void testslist() { slistnode*plist = NULL;//一开始定义一个指针，但啥都没有，所以先赋值空指针，作为头节点，存入第一个节点的地址 slistpushback(&plist, 1);//尾插.
链表的实现（文末附完整代码）
逃离枷锁，冲向天空！
11-12 3381
我们创建一个tail和prev，然后用循环将tail遍历到最后一个节点，循环的终止条件时tail->next为空，条件满足时就将tail赋予prev，当跳出循环时，prev就是尾节点的前一个节点，我们直接将tail给free掉，将其置空，这样尾节点就被删除了。头插比较简单，我们直接将新节点的next等于链表的第一个节点即可，也就是*pplist，我们传进来的是**pplist，是节点地址的地址，所以我们需要解引用一次才能将地址给newnode的next。
算法-链表
qq_42170897的博客
11-01 359
算法之链表
单链表分离(头插法和尾插法的结合,理解指针变换)
qq_57484399的博客
10-01 1071
强调,这两步不能颠倒,我们建立链表肯定会进行这两步操作是无疑的, 但是当我们覆盖一个指针的时候,要考虑这个指针里面是否存着我们需要的信息, 插入前,L2->next 里面存放的是第一个结点 的位置, 我们还要用到, 所以要先进行这一步, 然后再把新节点的位置给 头结点的尾指针.当判断bn 后面没有结点的时候, 我们就可以结束了, 刚才我们用 q 来存放 b 断开联系后的下一个结点 ,那当bn的尾指针是NULL的时候 , 我们就可以结束了, 意思就是不用连接了, 因为 bn 断开后, 没有后继节点了.
＜＜数据结构与算法＞＞---笔记(4) --- 单链表基本操作的实现
IDApprentice的博客
03-06 741
1) 取值--- 取单链表中第 i 个元素的内容 顺序表里如何找到第i个元素? L-> elem[i-1] 算法思路: 分别取出表中第 3 个元素和 第 15 个元素 链表是顺序存取结构 不是随机存储结构 2) 查找 1. 按值查找: 根据指定数据获取该数据所在的位置 (该数据的地址) 算法步骤: ...
数据结构与算法——单链表的逆序
icc_hhy的博客
05-21 1930
在之前，了解了单链表结点的删除和插入之后，大家会发现这种具有方向性的链表结构中增删结点是相当容易的一件事。要从头到尾输出整个单链表也不难，但是如果要反转过来输出单向链表就需要某些技巧了。单向链表的结点特性就是知道下一个结点的位置，可是却无法得知它上一个结点的位置。因此下面将介绍2中方法来实现单链表的逆序操作。
【数据结构与算法】单链表的插入和删除
热门推荐
一以贯之的努力 不得懈怠的人生
09-21 1万+
众所周知，顺序表中的每个结点中只存放数据元素，其优缺点为：优点：可随机存取，存储密度高；缺点：要求大片连续空间，改变容量不方便。而单链表中的每个结点除了存放数据元素外，还要存储指向下一个节点的指针，其优缺点为： 优点：不要求大片连续空间，改变容量方便 缺点：不可随机存取，要耗费一定空间存放指针
数据结构与算法-反转单链表
weixin_42560424的博客
05-29 545
在介绍问题之前，我们先简单了解一下单链表。单链表是一种线性数据结构，由一系列节点组成，每个节点包含两个部分：存储数据的部分和指向下一个节点的指针。链表的第一个节点称为头节点，最后一个节点的指针指向null，表示链表的结束。
数据结构与算法: 单链表的C语言实现及其基本操作解析
02-24
内容概要：本文介绍了单链表的数据结构以及如何用C语言实现单链表的基本操作，如初始化、插入（头插和尾插）、删除（头删和尾删）、查找元素、遍历打印。它深入解释了各种操作的具体步骤并提供了详细的代码片段以...
Java数据结构与算法-单链表 新浪，腾讯面试题详解
12-22
单链表常见的几个面试题 新浪，腾讯内部面试题目 题目分析 代码实现 测试用例 一，面试题目 统计链表中有效节点的个数（不含头结点）【新浪】 获取链表中倒数第K个元素【新浪】 单向链表的逆转【腾讯】 二，题目分析...
数据结构与算法-单链表的排序
04-21
数据结构与算法-单链表的排序
数据结构与算法-单链表的创建与操作
04-21
单链表的所有操作都有，文件里有两个头文件，一个cpp文件（运行时记得将最底下两个h文件单独拿出来）,非常整齐，说明也十分详细！
IP5326至为芯支持TYPE-C协议的2.4A充放电移动电源方案芯片
2501_92525625的博客
01-09 536
英集芯IP5326是一款专为移动电源、充电宝等便携设备设计的移动电源管理SOC芯片。集成Type-C协议与快充支持，支持2.4A同步充放电。
小红书笔记详情API接口基础解析：数据结构与调用方式
ID_18007905473的博客
01-09 438
小红书笔记详情 API 是提供笔记核心数据的标准化接口，主要用于合规场景下的内容展示、数据分析（需授权）等需求。该接口的设计围绕三大核心，其数据结构与调用方式具有鲜明的内容社区属性。
多模态AI 基于工业级编译技术的PLC数据结构解析与映射工具
会周易的程序猿的博客
01-06 1389
stDataCompiler是一款基于工业级编译技术的PLC数据结构解析工具，能够自动解析ST/C99代码中的变量定义并生成标准化JSON描述文件。该工具采用Flex/Bison构建词法语法分析器，实现从预处理、词法分析到AST构建的完整编译流程，支持结构体、联合体等复杂类型的自动提取和内存布局分析。通过CMake集成版本管理功能，输出结构化JSON数据模型，有效解决工业控制系统中底层数据与上层应用间的语义鸿沟问题，为PLC程序调试、系统集成和数据可视化提供统一的数据基础。
常用SCSI数据结构的详细注释和用法
追赶时代的博客
01-06 333
本文介绍了SCSI协议在USB存储设备中的核心数据结构及其应用。主要内容包括：1) SCSI命令块包装器(CBW)和状态包装器(CSW)的结构与用途，用于USB存储设备的命令封装和状态返回；2) 设备信息查询(INQUIRY)、容量报告(ReadCapacity)和错误感知(SenseData)等关键数据结构；3) 通用SCSI命令表示和请求封装方法。这些数据结构构成了SCSI协议栈的核心，特别适用于光存储项目中设备通信、识别、容量计算和错误处理等场景，为激光器/DMD控制命令的封装和管理提供了完整解决方案
03-BTC-数据结构
theflowerofac^MQLYES的专栏
01-08 713
摘要 区块链通过哈希指针构建防篡改链式结构，每个区块包含前驱区块的哈希值，篡改历史数据需重做后续所有区块的工作量证明。区块交易以默克尔树组织，根哈希存于区块头，实现高效成员验证。轻节点通过默克尔证明（包含交易哈希、兄弟哈希和位置索引）可验证交易存在性，复杂度O(logn)。非成员证明可通过排序默克尔树实现，但比特币未采用。哈希指针和默克尔树共同保障区块链数据完整性与验证效率。
408数据结构考纲知识点（更新中）
最新发布
weixin_50444005的博客
01-09 392
【考查目标】1.掌握数据结构的基本概念、基本原理和基本方法。2.掌握数据的逻辑结构、存储结构及基本操作的实现，能够对算法进行基本的时间复杂度与空间复杂度的分析。3.能够运用数据结构基本原理和方法进行问题的分析与求解，具备采用C或C++语言设计与实现算法的能力。数据结构是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合，以及定义在该集合上的一组操作。其核心在于研究数据的‌逻辑结构‌、‌存储结构‌（物理结构）及其‌运算‌。
数据结构与算法：单链表创建与练习解析
"完善算法-数据结构习题" 在数据结构的学习中，算法的设计和实现是至关重要的。这里给出的题目是关于单链表的创建，这是数据结构中的基本操作。首先，我们来看一下单链表的节点定义： ```c typedef struct ...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值