【探索数据结构与算法】——深入了解单链表

已于 2024-08-08 19:58:40 修改
阅读量459 收藏 9
点赞数 13
分类专栏： 数据结构与算法（c语言） 文章标签： 数据结构 算法
于 2024-08-08 16:22:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_80220709/article/details/141027565
版权

目录

 一、单链表的基本概念

二、单链表的基本结构 

三、单链表的基本操作 

1.链表打印

2.申请节点

3.头插 

4.尾插

5.头删

6.尾删

7.查找节点 

8.指定位置之前插入 

9.指定位置之后插入

10.删除给定节点 

11.删除给定节点之后的节点

12.链表销毁 

四、完整代码 

(1) SList.h

(2) SList.c

💓 博客主页：C-SDN花园GGbond

⏩ 文章专栏：探索数据结构与算法

 一、单链表的基本概念

单链表是一种基本的线性数据结构，它通过链式存储方式而非连续的内存位置来存储元素。（逻辑上连续，物理上不一定连续）在单链表中，每个元素（或称为节点）包含两部分：数据域和指针域。

数据域用于存储实际的数据，而指针域则存储指向下一个节点的地址。

这样，每个节点都链接到列表中的下一个节点，形成一个链条。

本篇文章要介绍的是无头结点，单向，不循环链表，即通常我们所熟知单链表，以下如无特殊说明，均代表此含义

 单链表的特点

  • 动态大小：链表的长度可以在运行时改变，便于灵活地添加和删除元素。
  • 不需要连续空间：与数组不同，链表的节点在内存中不必相邻，这使得它在内存管理上更为灵活。
  • 插入和删除操作高效：在已知节点位置的情况下，插入和删除操作可以仅需常数时间完成，因为只需调整相邻节点的指针即可。
  • 访问速度：相比于随机访问的数组，单链表的元素访问效率较低，因为需要从头节点开始逐个遍历直到目标节点。

二、单链表的基本结构 

在单链表中，每个元素（或称为节点）包含两部分：数据域和指针域。

数据域用于存储实际的数据（可以是任意类型的数据），而指针域则存储指向下一个节点的地址。

下面是一个使用结构体定义单链表节点的示例：

​​​

typedef int SLTDataType;//类型重定义
typedef struct SListNode
{
	SLTDataType data;//数据
	struct SListNode* next;//指针
}SLTNode;

注意 ：

  •  例子中int是要存储的数据类型，但为了方便后期修改存储类型，这里先对int重命名
  • 为了方便使用，简化节点的名字为SLTNode（但要注意在结构体中创建指针时，不可以使用重定义后的结构体名称，因为此时结构体还未定义）

三、单链表的基本操作 

  1. 打印单链表中的数据。
  2. 申请节点。
  3. 对单链表进行头插(开头插入数据)。
  4. 对单链表进行尾插(末尾插入数据)。
  5. 对单链表进行头删(开头删除数据)。
  6. 对单链表进行尾删(末尾删除数据)。
  7. 对单链表进行查找数据。
  8. 对单链表数据进行修改。
  9. 任意位置的删除和插入数据。
  10. 销毁单链表。
1.链表打印
void SLTPrint(SLTNode* phead)//链表打印
{
	SLTNode* pcur = phead;
	while (pcur)//pcur!=NULL
	{
		printf("%d->", pcur->data);//打印该节点数据
		pcur = pcur->next;//指针指向下一个节点
	}
	printf("NULL\n");
}

该方法的思路是创建一个临时指针变量接收实参传递的链表首节点指针

然后进入循环，当临时指针pcur不为空时，打印该节点的数据，然后指向下一个节点

当传递来的实参为NULL时，不会进入while循环，而是直接打印NULL 

2.申请节点
SLTNode* NewNode(SLTDataType x)//申请节点
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)//注意这里不要写成一个=
	{
		perror("newnode");
		exit(1);//如果申请节点失败，异常退出程序
	}
	newnode->data = x; //数据初始化
	newnode->next = NULL;//指针初始化
	return newnode;//返回新申请节点的地址
}

该方法的思路是：

  • 动态开辟一块节点大小的空间，判断是否成功
  • 然后分别对数据和指针部分初始化 

3.头插 
void SLTPushFront(SLTNode** pphead, SLTDataType x)//头插
{
	assert(pphead);//二级指针不能为空，否则解引用就会报错
	SLTNode* newnode = NewNode(x);
	newnode->next = *pphead;//新节点next指针指向原来的首节点
	*pphead = newnode;//新节点成为首节点
}

单链表的头插与顺序表头插最大的不同就是单链表传参需要二级指针。因为头插数据需要改变一级指针的指向，而形参的改变无法影响实参，所以需要二级指针才能改变一级指针的指向。

4.尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)//尾插
{
	assert(pphead);//二级指针不能为空，否则解引用就会报错
	SLTNode* newnode = NewNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;//如果链表为空，新节点即为第一个节点
	}
	else
	{
		SLTNode* pcur = *pphead;
		while (pcur->next)//找到链表的尾节点
		{
			pcur = pcur->next;
		}
		pcur->next = newnode;//如果不对空链表分别处理
	}						//此处就会对空指针解引用
}

该方法思路：

  • 对二级指针判空
  • 申请新节点
  •  对于空链表和非空链表分开处理
  1. 对于空链表，新节点成为首节点
  2. 对于非空链表，要先找到尾节点，修改尾节点的next指针指向新节点

5.头删
void SLTPopFront(SLTNode** pphead)//头删
{
	assert(pphead && *pphead);//二级指针不能为空，链表不能为空
	SLTNode* next = (*pphead)->next;//存储第二个节点
	free(*pphead);//删除第一个节点
	*pphead = next;//链表指向第二个节点
}

该方法思路：

  • 判空
  • 先存储下第二个节点，防止删除第一个节点之后找不到第二个节点
  • 删除第一个节点
  • 链表头指针指向第二个节点
  • （这段代码对于链表只有一个节点的情况也可以正常处理）

6.尾删
void SLTPopBack(SLTNode** pphead)//尾删
{
	assert(pphead && *pphead);//二级指针不能为空，链表不能为空
	if ((*pphead)->next == NULL)//处理链表只有一个节点的情况
	{
		free(*pphead);
		*pphead = NULL;
	}
	else//处理正常情况
	{
		SLTNode* pcur = *pphead;//找到指针的最后一个节点
		SLTNode* prev = *pphead;//找到指针的倒数第二个节点
		while (pcur->next)
		{
			prev = pcur;
			pcur = pcur->next;
		}
		free(pcur);
		pcur = NULL;
		prev->next = NULL;//如果不做特殊处理，此处就会对空指针解引用
	}
}

该方法思路：

  • 判空
  • 对于链表只有一个节点或多个节点的情况分别处理
  1. 链表只有一个节点——先删除，再置空
  2. 链表有多个节点——先找到链表的最后一个和倒数第二个节点，最后一个节点删除和置空，倒数第二个节点的next指向NULL

7.查找节点 
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
    assert(phead)
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
			return pcur;//如果找到，返回节点地址
        pcur=pcur->next；

	}
	return NULL;//对未找到的情况和链表为空的情况都可以处理
}

该方法完成的思路：

创建一个临时指针变量接收实参传递的链表首节点指针
while循环，当临时指针pcur不为空时，判断该节点数据是否等于要查找的数据，相等直接返回节点地址，否则指针指向下一个节点
如果while循环中没有return，说明未找到指定数据，或链表为空，此时返回一个空指针

8.指定位置之前插入 
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);//二级指针不能为空，链表不能为空
	assert(pos);//指定位置必须存在
	SLTNode* newnode = NewNode(x);
	if (*pphead == pos)//如果要插入到第一个节点之前
	{
		SLTPushFront(pphead, x);//可以直接调用头插
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)//需要先找到pos的前一个节点
		{                        //如果不分别处理，最后就会对空指针解引用
			prev = prev->next;
		}
		newnode->next = pos;//新节点指向pos
		prev->next = newnode;//原pos的前一个节点指向新节点
	}
 
}

该方法完成的任务：

  • 判空
  • 申请节点
  • 对于指定的位置分情况处理
  1. 如果指定的位置就是第一个节点，那么直接调用头插
  2. 对于其他情况，需要先找到pos的前一个节点。然后将三个节点链接在一起：原pos的前一个节点-> 新节点->pos节点

9.指定位置之后插入
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);//pos节点必须存在
	SLTNode* newnode = NewNode(x);
	newnode->next = pos->next;//新节点的next指针指向原pos的下一个节点
	pos->next = newnode;//pos的next指针指向新节点
}

该方法完成的思路：

  • 判空
  • 申请节点
  • 新节点的next指针指向原pos的下一个节点
  • pos的next指针指向新节点（注意这两条语句不能颠倒，否则pos之后的节点就会丢失）

10.删除给定节点 
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *pphead);//二级指针不能为空，链表不能为空
	assert(pos);//指定位置必须存在
	if (pos == *pphead)//如果删除的是首节点，或链表只有一个节点
	{
		SLTPopFront(pphead);
	}
	else//链表有多个节点，且删除的不是首节点
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)//如果不分开处理，这里就可能对空指针解引用
		{
			prev = prev->next;
		}
		prev->next = pos->next;//找到前一个指针，并将其next指针指向pos的next指针所指节点
		free(pos);
		pos = NULL;
	}
}

该方法完成的思路：

  • 判空
  • 对两种情况分别处理
  1. 如果删除的是首节点，或链表只有一个节点，直接执行头删
  2. 如果链表有多个节点，且删除的不是首节点。那么先找到pos的前一个指针，并将其next指针指向pos的next指针所指节点

11.删除给定节点之后的节点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);//pos节点必须存在且pos之后必须存在节点
	SLTNode* del = pos->next;//预先存储要删除的节点，防止修改指针之后找不到要删除的节点
	pos->next = del->next;
	free(del);
	del = NULL;
}

该方法完成的思路：

  • 判空
  • 预先存储要删除的节点，防止修改指针之后找不到要删除的节点
  • pos的next指针指向要删除节点的next指针所指向的节点（或NULL）
  • 删除pos之后的节点并置空

12.链表销毁 
void SListDesTroy(SLTNode** pphead)
{
	assert(pphead && *pphead);//二级指针不能为空，链表不能为空
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;//需要预先存储当前要删除节点的下一个节点
		free(pcur);					//否则就找不到下一个节点了
		pcur = next;
	}
	*pphead = NULL;//删除完所有节点之后，链表置空
}

该方法完成的思路：

  • 判空
  • 创建一个临时指针变量接收实参传递的链表首节点指针
  • while循环，当临时指针pcur不为空时，存储下一个节点的地址，并删除该节点，pcur指向下一个节点
  • 删除完所有节点之后，不要忘记给链表指针置为NULL，预防野指针

四、完整代码 

(1) SList.h
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef int SLTDataType;//类型重定义
typedef struct SListNode
{
	SLTDataType data;//数据
	struct SListNode* next;//指针
}SLTNode;
 
 
void SLTPrint(SLTNode* phead);//链表打印
 
SLTNode* NewNode(SLTDataType x);//申请节点
 
//头部插入删除/尾部插入删除
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);
//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos);
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);
//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos);
//销毁链表
void SListDesTroy(SLTNode** pphead);
(2) SList.c
#include"SLinkList.h"
void SLTPrint(SLTNode* phead)//链表打印
{
	SLTNode* pcur = phead;
	while (pcur)//pcur!=NULL
	{
		printf("%d->", pcur->data);//打印该节点数据
		pcur = pcur->next;//指针指向下一个节点
	}
	printf("NULL\n");
}
 
SLTNode* NewNode(SLTDataType x)//申请节点
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)//注意这里不要写成一个=
	{
		perror("newnode");
		exit(1);//如果申请节点失败，异常退出程序
	}
	newnode->data = x; //数据初始化
	newnode->next = NULL;//指针初始化
	return newnode;//返回新申请节点的地址
}	
 
//头部插入删除/尾部插入删除
void SLTPushBack(SLTNode** pphead, SLTDataType x)//尾插
{
	assert(pphead);//二级指针不能为空，否则解引用就会报错
	SLTNode* newnode = NewNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;//如果链表为空，新节点即为第一个节点
	}
	else
	{
		SLTNode* pcur = *pphead;
		while (pcur)//找到链表的尾节点
		{
			pcur = pcur->next;
		}
		pcur->next = newnode;//如果不对空链表分别处理
	}						//此处就会对空指针解引用
}
void SLTPushFront(SLTNode** pphead, SLTDataType x)//头插
{
	assert(pphead);//二级指针不能为空，否则解引用就会报错
	SLTNode* newnode = NewNode(x);
	newnode->next = *pphead;//新节点next指针指向原来的首节点
	*pphead = newnode;//新节点成为首节点
}
 
void SLTPopBack(SLTNode** pphead)//尾删
{
	assert(pphead && *pphead);//二级指针不能为空，链表不能为空
	if ((*pphead)->next == NULL)//处理链表只有一个节点的情况
	{
		free(*pphead);
		*pphead = NULL;
	}
	else//处理正常情况
	{
		SLTNode* pcur = *pphead;//找到指针的最后一个节点
		SLTNode* prev = *pphead;//找到指针的倒数第二个节点
		while (pcur->next != NULL)
		{
			prev = pcur;
			pcur = pcur->next;
		}
		free(pcur);
		pcur = NULL;
		prev->next = NULL;//如果不做特殊处理，此处就会对空指针解引用
	}
}
 
void SLTPopFront(SLTNode** pphead)//头删
{
	assert(pphead && *pphead);//二级指针不能为空，链表不能为空
	SLTNode* next = (*pphead)->next;//存储第二个节点
	free(*pphead);//删除第一个节点
	*pphead = next;//链表指向第二个节点
}
 
//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
			return pcur;//如果找到，返回节点地址
	}
	return NULL;//对未找到的情况和链表为空的情况都可以处理
}
 
//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);//二级指针不能为空，链表不能为空
	assert(pos);//指定位置必须存在
	SLTNode* newnode = NewNode(x);
	if (*pphead == pos)//如果要插入到第一个节点之前
	{
		SLTPushFront(pphead, x);//可以直接调用头插
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)//需要先找到pos的前一个节点
		{						//如果不分别处理，最后就会对空指针解引用
			prev = prev->next;
		}
		newnode->next = pos;//新节点指向pos
		prev->next = newnode;//原pos的前一个节点指向新节点
	}
 
}
 
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);//pos节点必须存在
	SLTNode* newnode = NewNode(x);
	newnode->next = pos->next;//新节点的next指针指向原pos的下一个节点
	pos->next = newnode;//pos的next指针指向新节点
}
 
//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *pphead);//二级指针不能为空，链表不能为空
	assert(pos);//指定位置必须存在
	if (pos == *pphead)//如果删除的是首节点，或链表只有一个节点
	{
		SLTPopFront(pphead);
	}
	else//链表有多个节点，且删除的不是首节点
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)//如果不分开处理，这里就可能对空指针解引用
		{
			prev = prev->next;
		}
		prev->next = pos->next;//找到前一个指针，并将其next指针指向pos的next指针所指节点
		free(pos);
		pos = NULL;
	}
}
 
//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);//pos节点必须存在且pos之后必须存在节点
	SLTNode* del = pos->next;//预先存储要删除的节点，防止修改指针之后找不到要删除的节点
	pos->next = del->next;
	free(del);
	del = NULL;
}
 
//销毁链表
void SListDesTroy(SLTNode** pphead)
{
	assert(pphead && *pphead);//二级指针不能为空，链表不能为空
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;//需要预先存储当前要删除节点的下一个节点
		free(pcur);					//否则就找不到下一个节点了
		pcur = next;
	}
	*pphead = NULL;//删除完所有节点之后，链表置空
}

C-SDN花园GGbond
关注
  • 13
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法——9（单链表插入 删除 查找的实现）
sabiregrow的博客
10-12 63
数据结构与算法——找出单链表中的倒数第k个元素
beilizhang的博客
07-26 1238
如何找出单链表中的倒数第k个元素 方法一：顺序遍历两遍 首先遍历一遍单链表，求出整个单链表的长度n，然后把求倒数第k个元素转换为求正数第n-k个元素，再去遍历一次就可以得到结果 方法二：快慢指针法 在查找过程中，设置两个指针，让其中一个指针比另一个指针先前移k步，然后两个指针同时往前移动。循环，直到先行的指针值为NULL时，另一个指针所指的位置就是所要找的位置 struct ListNode { int val; ListNode *next; ListNode() : val(0)
数据结构与算法——单链表的逆序
icc_hhy的博客
05-21 1126
在之前，了解了单链表结点的删除和插入之后，大家会发现这种具有方向性的链表结构中增删结点是相当容易的一件事。要从头到尾输出整个单链表也不难，但是如果要反转过来输出单向链表就需要某些技巧了。单向链表的结点特性就是知道下一个结点的位置，可是却无法得知它上一个结点的位置。因此下面将介绍2中方法来实现单链表的逆序操作。
数据结构与算法——删除单链表中的重复结点
beilizhang的博客
07-26 8970
如何删除单链表中的重复结点 方法一：递归 对于一个结点head，首先把链表head->next作为头结点的链表中的重复项删除，然后遍历head->next为头结点的链表中的元素，判断遍历到的元素是否与head结点元素相等，如果相等，则删除。对于head->next为头结点的链表而言，可以使用同样的思路来删除以head->next->next为头结点的链表中的重复元素。因此可以使用递归的方法求解 struct ListNode { int val; ListNod
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构与算法——单链表的基本操作的实现
weixin_68773927的博客
10-21 2164
（从链表的头指针出发，顺着链域next逐个结点往下搜索，直至搜索到第i个为止，因此，链表不是随机存取结）链表任然存在，但链表中无元素，成为空链表（头指针和头节点任然存在）空表：链表中无元素，称为空链表(头指针和头节点任然存在）按值查找：根据指定数据获取该数据所在的位置序号（是第几个数据元素）按值查找：根据指定数据获取该数据元素所在的位置（该数据的地址）算法思路：从首元结点开始，依次计算所有节点。算法思路：从头指针开始，依次释放所有结点。思路：判断头节点指针域是否为空。算法步骤：（找到i-1结点）
数据结构与算法学习——单链表相关算法
苏州程序大白的博客
12-27 264
数据结构与算法学习——单链表相关算法目录博主介绍前言使用java实现单链表编写代码实现单链表的反转将两个有序单链表合并为一个有序单链表返回链表中倒数第K个结点????点击直接资料领取???? 目录 博主介绍 ???? 个人主页:苏州程序大白 ???? 个人社区:CSDN全国各地程序猿 ????作者介绍：中国DBA联盟(ACDU)成员，CSDN全国各地程序猿（媛）聚集地管理员。目前从事工业自动化软件开发工作。擅长C#、Java、机器视觉、底层算法等语言。2019年成立柒月软件工作室，2021年注册苏州
【数据结构与算法】深入理解 单链表
2302_78391795的博客
05-07 1257
单链表是一种基本的线性数据结构，它通过链式存储方式而非连续的内存位置来存储元素。（逻辑上连续，物理上不一定连续）在单链表中，每个元素（或称为节点）包含两部分：数据域和指针域。 数据域用于存储实际的数据，而指针域则存储指向下一个节点的地址。 这样，每个节点都链接到列表中的下一个节点，形成一个链条。 本篇文章要介绍的是无头结点，单向，不循环链表，即通常我们所熟知单链表，以下如无特殊说明，均代表此含义。
数据结构与算法——单链表（1）
wangjiaju960914的博客
08-28 440
数据结构与算法——单链表（1） 链表介绍 链表是有序的列表，但是它在内存中是存储如下： 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点的data域 如图：发现链表的各个节点不一定是连续存储 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表的介绍 单链表(带头结点) 逻辑结构示意图如下 使用带头节点的单向链表实现人物的增删改查操作，此处是第一种较为简单的方法，直接添加到链表的尾部。 思路分析 此处主要演示的是添加（创建） 先创建
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
【数据结构-前缀哈希】力扣523. 连续的子数组和
sjsjs11的博客
08-05 363
当发现有两个余数相同的key的时候，对他们value作差，如果大于等于二，说明该子段长度大于等于二，这时候就找到了一个好的子数组，返回true，如果到最后都没有找到这样一个好的子数组，返回false。，其中 m 是数组 nums 的长度。解释：[23, 2, 6, 4, 7] 是大小为 5 的子数组，并且和为 42。输入：nums = [23,2,6,4,7], k = 13。输入：nums = [23,2,4,6,7], k = 6。输入：nums = [23,2,6,4,7], k = 6。
常见8种数据结构
qq_43575301的博客
08-08 658
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
数据结构：栈（含源码）
2401_86551514的博客
08-05 575
先判断容量是否有足够的空间让数据入栈，在第一次入栈是先给定4个空间，后面每次不够时就将空间数乘以2， 还有一个判断是否开辟成功（这个可以不写，一般都会开辟成功）。栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底，栈中的数据元素遵守后进先出的原则。我们在创建栈时，一般是创建支持动态增长的栈，定长的静态栈不实用。出栈非常的简单，只要将top数减少一个就行了，相当于是下一次入栈是直接把这个数据修改掉，就算没修改，打印时也不影响。
数据结构：链表经典算法OJ题
2401_86551514的博客
08-04 1040
在了解了链表的相关知识后，我们还需要一些题目进行练习加深对链表这方面知识的理解，也可以用来检测链表这块学的的怎么样，废话不多说，开始上手。
【数据结构】数组复习-二分查找法
最新发布
weixin_54096215的博客
08-08 338
[34] 在排序数组中查找元素的第一个和最后一个位置left = 0else:else:left = 0else:main()c++public:} else {left = 0;
数据结构——链式结构二叉树
2301_81888634的博客
08-02 705
我们已经学习了实现二叉树的两种方法：顺序结构（堆）和链式结构。敬请期待“二叉树OJ题”~
数据结构-递归
B13646141775的博客
08-05 839
递归简单实现及如何阅读递归代码
数据结构3—单链表（附源码）
l1894的博客
08-05 306
概念：链表是一种、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的实现的。结构：由一个个结点构成，每个结点是一个结构体（里面包含了数据域和指针域，其中指针域存储的是下一个结点的地址）
【数据结构的——红黑树】
Pumpkin_O的博客
08-08 806
红黑树是一种自平衡的二叉查找树，是一种高效的查找树，可以在Olog2n时间内完成查找、增加和删除等操作。有了二叉搜索树，为什么需要平衡二叉树？对于二叉搜索树，如果插入的数据是随机的，那么它就是接近平衡的二叉树，平衡二叉树（AVLTree）的操作效率较高，查增删的时间复杂度都是Olog2n。但是当插入的数据有序时，二叉搜索树的结点就会只在根结点的一侧，就变成了一个链表，操作效率也因此变低，时间复杂度变为了O(n)。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值