【数据结构与算法】数据结构初阶：详解顺序表和链表（四）——单链表（下）

已于 2025-07-12 10:44:16 修改
阅读量864 收藏 13
点赞数 38
CC 4.0 BY-SA版权
分类专栏： 数据结构与算法 文章标签： 链表 数据结构 c语言 开发语言 学习 算法
于 2025-07-12 08:36:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_89899187/article/details/149282726

 

 🔥个人主页：艾莉丝努力练剑

❄专栏传送门：《C语言》、《数据结构与算法》、C语言刷题12天IO强训、LeetCode代码强化刷题

🍉学习方向：C/C++方向

⭐️人生格言：为天地立心，为生民立命，为往圣继绝学，为万世开太平

前言：本篇文章，我们复盘顺序表和链表相关的知识点，在初阶的数据结构与算法阶段，我们把知识点分成三部分，复杂度作为第一部分，顺序表和链表、栈和队列、二叉树为第二部分，排序为第二部分，我们之前已经介绍完了第一部分：算法复杂度，本文我们继续学习第二部分中的顺序表和链表部分内容啦。

        半个多月前，博主更新了头插、尾删、头删、随机位置插入、随机位置删除、查找、修改、菜单等内容，本篇文章，我们就来复盘一下动态顺序表的内容，博主会添加很多新内容，希望对大家的顺序表学习有所帮助。

​ 

目录

正文

三、单链表

（二）实现单链表

3、增删查改

增

（1）尾插

（2）头插

（3）在指定位置之前插入数据

（4）在指定位置之后插入数据

删

（1）尾删

（2）头删

（3）删除pos节点

（4）删除pos之后的节点

查

（1）查找

改 

（1）修改

 销毁链表

（1）销毁链表

4、完整代码 

（1）SList.h：

（2）SList.c：

（3）test.c：

结尾

正文

提醒：为什么我们要学那么多的数据结构？这是因为没有一种数据结构能够去应对所有场景。我们在不同的场景需要选择不同的数据结构，所以数据结构没有谁好谁坏之分，而评估数据结构的好坏要针对场景，如果在一种场景下我们需要频繁地对头部进行插入删除操作，那么这个时候我们用链表；但是如果对尾部进行插入删除操作比较频繁，那我们用顺序表比较好。

        因此，不同的场景我们选择不同的数据结构。

三、单链表

（二）实现单链表

3、增删查改
增
（1）尾插

我们要申请新的节点（需要malloc），我们单独封装一个函数。

​

现在新节点就申请好了，我们要让5和4节点连起来：

​

这就是为什么我们明明已经有phead这个指针，还要额外再定义一个指针pcur——

​

这样一来pcur在不断变化，phead保持不变，phead始终保存的是第一个节点的地址。在这里我不想改变phead，phead始终指向第一个节点，方便我们后面遍历完了如果还要再从头开始遍历的时候我们能够找到第一个节点的地址。

我们定义pcur，只要pcur不为空，我们就进入循环，pcur为空我们就跳出循环。

​

我们这边调用test02： 

​

 这是SList.c尾插的代码：

//尾插
void SLTPushBack(​SLTNode* phead, SLTDatatype x)
{
	//申请新节点
	​SLTNode* newnode = SLTBuyNode(x);
	//链表为空——要特殊处理
	if (phead == NULL)
	{
		phead = newnode;
	}
	​SLTNode* ptail = phead;
	while (ptail->next != NULL)
	{
		ptail = ptail->next;
	}
	//找到了尾节点 ptail newnode
	ptail->next = newnode;
}

这边其实代码还是有问题的，我们先运行一下看看：

​

尾插： 

SList.c：

//尾插
void SLTPushBack(​SLTNode** pphead, SLTDatatype x)
{
	//申请新节点
	​SLTNode* newnode = SLTBuyNode(x);
	//链表为空——要特殊处理
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		​SLTNode* ptail = *pphead;
		while (ptail->next != NULL)
		{
			ptail = ptail->next;
		}
		//找到了尾节点 ptail newnode
		ptail->next = newnode;
	}
}

test.c： 

void test02()
{
	//创建空链表
	​SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);
}

int main()
{
	/*test01();*/
	test02();
	return 0;
}

​

尾插的时间复杂度：O(N) 。

（2）头插

​

头插：

SList.c：

//头插
void SLTPushFront(​SLTNode** pphead, SLTDatatype x)
{
	assert(pphead);
	​SLTNode* newnode = SLTBuyNode(x);
	//newnode *pphead
	newnode->next = *pphead;
	*pphead = newnode;
}

test.c： 

void test02()
{
	//创建空链表
	​SLTNode* plist = NULL;
    SLTPushFront(&plist, 1);
	SLTPrint(plist);
	SLTPushFront(&plist, 2);
	SLTPrint(plist);
	SLTPushFront(&plist, 3);
	SLTPrint(plist);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);
}

int main()
{
	/*test01();*/
	test02();
	return 0;
}

​

头插的时间复杂度：O(1) 。 

（3）在指定位置之前插入数据

函数形参中同样需要用二级指针传入链表地址，还要传入指定位置的地址和需要插入的数据。

在函数中，需要先找到指定位置的前一个节点，然后把需要添加的数据插入到这两个节点之间：

SList.c：

void SLTPushBefore(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
    assert(pphead && pos);
    //当pos为头节点时 相当于头插
    if(*pphead == pos)
    {
        SLTPushFront(pphead, x);
    }
    else
    {
        SLTNode* newNode = SLTBuyNode(x);
        //找到pos前一个节点
        SLTNode* pre = *pphead;
        while(pre->next != pos)
        {
            pre = pre->next;
        }
        
        //把新节点放在pre和pos之间
        newNode->next = pre->next;//等价于newNode->next = pos
        pre->next = newNode;
    }
    
}

test.c： 

void test02()
{
	//创建空链表
	​SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	​SLTNode* pos = SLTFind(plist, 4);

	SLTInsert(&plist, pos, 100);
	SLTPrint(plist);
}

int main()
{
	/*test01();*/
	test02();
	return 0;
}

在指定位置之前插入数据时间复杂度：O(N)。 

（4）在指定位置之后插入数据

和类似，我们找到指定位置的后一个节点，把新节点放在这两个节点之间——

4后面插入一个100： 

1后面插入一个100：

SList.c：

void SLTInsertAfter(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
    assert(pphead && pos);
    if(pos->next == NULL)
    {
        //相当于尾插
        SLTPushBack(pphead, x);
    }
    else
    {
        SLTNode* newNode = SLTBuyNode(x);
        newNode->next = pos->next;
        pos->next = newNode;
        //顺序不能颠倒 否则会先修改pos->next
    }
}

test.c： 

void test02()
{
	//创建空链表
	​SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	​SLTNode* pos = SLTFind(plist, 1);

	//SLTInsert(&plist, pos, 100);
	SLTInsertAfter(pos, 100);
	SLTPrint(plist);
}

int main()
{
	/*test01();*/
	test02();
	return 0;
}

在指定位置之后插入数据时间复杂度：O(1)。  

删
（1）尾删

pphead和phead的关系：

本文中的pphead是形参，phead是画图时定义的一个指针。

phead是指向第一个结点的指针；

在程序里面，指向第一个节点的指针在形参里面是*pphead。

函数形参中二级指针存放表头地址。

如果链表只有一个元素需要释放头节点的空间，并把链表指针置为空；

如果有多个元素需要找到倒数第二个节点和最后一个节点，释放最后一个节点，并把倒数第二个节点的next指针置为空。

​出问题了： 

​

万一链表只有一个节点，我们要注意这种情况——

尾删：

SList.c：

//尾删
void SLTPopBack(​SLTNode** pphead)
{
	//链表为空不能删除
	assert(pphead && *pphead);
	//pphead是*pphead的地址
	//pphead是一个二级指针，我们对pphead解引用一次，*pphead就是指向第一个节点的地址
	//*pphead为空说明链表为空
	//链表只有一个节点的情况
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		​SLTNode* prev = NULL;
		​SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		//prev  ptail
		prev->next = NULL;
		free(ptail);
		ptail = NULL;
	}
}

test.c：

void test02()
{
	//创建空链表
	​SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);
	//SLTPushFront(&plist, 1);
	//SLTPrint(plist);
	//SLTPushFront(&plist, 2);
	//SLTPrint(plist);
	//SLTPushFront(&plist, 3);
	//SLTPrint(plist);
	//SLTPushFront(&plist, 4);
	//SLTPrint(plist);

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

int main()
{
	/*test01();*/
	test02();
	return 0;
}

​

链表为空，如果还要再删一次，程序就会assert(断言)报错：

​

​

表达式为假，因为*pphead为空了，在69行断言出现了报错。

如果初始将prev置为*pphead也要讨论：

这样两个指针都指向这个节点，让prev下一个节点置为空——本身它下一个节点就为空，现在把ptail 给 free掉，prev就变成了野指针。

如果只有一个节点，prev->next = NULL;这一行代码就可以不要了，而且ptail和prev都要free。如果不止一个节点的话，那这又是一套逻辑，这种写法会更复杂一些。

博主给出的这种写法会简单一些。 

尾删的时间复杂度：O(N) 。 

（2）头删

与尾删相似，让头指针指向第二个节点，并释放头节点——

​

头删：

SList.c： 

//头删
void SLTPopFront(​SLTNode** pphead)
{
	assert(pphead && *pphead);
	​SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

test.c：

void test02()
{
	//创建空链表
	​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()
{
	/*test01();*/
	test02();
	return 0;
}

再删一次就会断言报错——

​

​

头删的时间复杂度：O(1) 。

（3）删除pos节点

让pos前一个节点指向pos后一个节点——

SList.c：

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
    assert(pphead && pos && *pphead);
    //pos为头节点
    if(pos == *pphead)
    {
        free(*pphead);
        *pphead = NULL;
        pos = NULL;
    }
    else
    {
        SLTNode* prev = *pphead;
        while(prev->next != pos)
        {
            prev = prev->next;
        }
        prev->next = pos->next;
        free(pos);
        pos = NULL;
    }
}

test.c：

void test02()
{
	//创建空链表
	​SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	​SLTNode* pos = SLTFind(plist, 3);

	SLTErase(&plist, pos);
	SLTPrint(plist);
}

int main()
{
	/*test01();*/
	test02();
	return 0;
}
（4）删除pos之后的节点

找到pos之后的节点del，连接pos节点和del->next，再释放del——

SList.c：

void SLTEraseAfter(SLTNode** pphead, SLTNode* pos)
{
    assert(pphead && pos && pos->next && *pphead);
    SLTNode* del = pos->next;
    pos->next = del->next;
    free(del);
    del = NULL;
}

test.c：

void test02()
{
	//创建空链表
	​SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	​SLTNode* pos = SLTFind(plist, 3);

	SLTErase(&plist, pos);
	SLTPrint(plist);
}

int main()
{
	/*test01();*/
	test02();
	return 0;
}
​
查
（1）查找

来个不存在的数据测试一下—— 

查找 

SList.c：

//查找
​SLTNode* SLTFind(​SLTNode* phead, SLTDatatype x)
{
	​SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//未找到
	return NULL;
}

test.c：

void test02()
{
	//创建空链表
	​SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	​SLTNode* pos = SLTFind(plist, 100);
	if (pos)
	{
		printf("找到了！\n");
	}
	else
	{
		printf("未找到！\n");
	}
}



int main()
{
	/*test01();*/
	test02();
	return 0;
}
改 
（1）修改

修改指定位置的数据：直接修改该节点data的值——

SList.c：

void SLTChangeData(SLTNode* pos, SLTDataType x)
{
    assert(pos);
    pos->data = x;
}
 销毁链表

遍历链表，释放每一个节点，由于需要修改指向头节点的指针，因此函数形参中要用二级指针——

（1）销毁链表

SList.c：

void SLTDestroy(SLTNode** pphead)
{
    assert(pphead );
    SLTNode* pcur = *pphead;
    while(pcur)
    {
        SLTNode* next = pcur->next;
        free(pcur);
        pcur = next;
    }
    *pphead = NULL;
}

这里pos=NULL、pcur=NULL、next=NULL加上置为空是养成好习惯，这里是默认置为空。 

test.c： 

void test02()
{
	//创建空链表
	​SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

    ​SLTNode* pos = SLTFind(plist, 3);

    SListDestory(&plist);
}

int main()
{
	/*test01();*/
	test02();
	return 0;
}
4、完整代码 
（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;

//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);

//在指定位置之前插入数据
void SLTInsert(​SLTNode** pphead, ​SLTNode* pos, SLTDatatype x);

//在指定位置之后插入数据
void SLTInsertAfter(​SLTNode* pos, SLTDatatype x);

//删除pos节点
void SLTErase(​SLTNode** pphead, ​SLTNode* pos);

//删除pos之后的节点
void SLTEraseAfter(​SLTNode* pos);

//修改
void SLTChangeData(​SLTNode* pos, SLTDatatype x);

//销毁链表
void SListDestory(​SLTNode** pphead);
（2）SList.c：
#define  _CRT_SECURE_NO_WARNINGS  1

#include"SList.h"

void SLTPrint(​SLTNode* phead)
{
	​SLTNode* pcur = phead;
	while (pcur != NULL)
	{
		printf("%d -> ", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

//后续我们要申请新节点就直接调用SLTBuyNode方法
​SLTNode* SLTBuyNode(SLTDatatype x)
{
	​SLTNode* newnode = (​SLTNode*)malloc(sizeof(​SLTNode));
	//malloc不一定申请成功，我们判断一下
	if (newnode == NULL)
	{
		printf("malloc fail!");
		exit(1);
	}
	//初始化一下
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

//尾插
void SLTPushBack(​SLTNode** pphead, SLTDatatype x)
{
	//申请新节点
	​SLTNode* newnode = SLTBuyNode(x);
	//链表为空——要特殊处理
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		​SLTNode* ptail = *pphead;
		while (ptail->next != NULL)
		{
			ptail = ptail->next;
		}
		//找到了尾节点 ptail newnode
		ptail->next = newnode;
	}
}

//头插
void SLTPushFront(​SLTNode** pphead, SLTDatatype x)
{
	assert(pphead);
	​SLTNode* newnode = SLTBuyNode(x);
	//newnode *pphead
	newnode->next = *pphead;
	*pphead = newnode;
}

//尾删
void SLTPopBack(​SLTNode** pphead)
{
	//链表为空不能删除
	assert(pphead && *pphead);
	//pphead是*pphead的地址
	//pphead是一个二级指针，我们对pphead解引用一次，*pphead就是指向第一个节点的地址
	//*pphead为空说明链表为空
	//链表只有一个节点的情况
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		​SLTNode* prev = NULL;
		​SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		//prev  ptail
		prev->next = NULL;
		free(ptail);
		ptail = 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;
		}
		pcur = pcur->next;
	}
	//未找到
	return NULL;
}

//在指定位置之前插入数据
void SLTInsert(​SLTNode** pphead, ​SLTNode* pos, SLTDatatype x)
{
	assert(pphead && pos);
	​SLTNode* newnode = SLTBuyNode(x);
	//pos指向头节点
	if (pos == *pphead)
	{
		//头插
		SLTPushFront(pphead, x);
	}
	else
	{
		//找pos前一个节点
		​SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		//prev   newnode  pos
		prev->next = newnode;
		newnode->next = pos;
	}
}

//在指定位置之后插入数据
void SLTInsertAfter(​SLTNode* pos, SLTDatatype x)
{
	assert(pos);
	​SLTNode* newnode = SLTBuyNode(x);
	//pos newnode pos->next
	newnode->next = pos->next;
	pos->next = newnode;
}

//删除pos节点
void SLTErase(​SLTNode** pphead, ​SLTNode* pos)
{
	assert(pphead && pos);
	//pos刚好是头节点——头删
	if (pos==*pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		​SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		//prev pos pos->next
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

//删除pos之后的节点
void SLTEraseAfter(​SLTNode* pos)
{
	assert(pos);
	//pos  del  del->next
	​SLTNode* del = pos->next;
	pos->next = del->next;
	free(del);
	del = NULL;
}

//修改
void SLTChangeData(​SLTNode* pos, SLTDatatype x)
{
	assert(pos);
	pos->data = x;
}

//销毁链表
void SListDestory(​SLTNode** pphead)
{
	//一个一个销毁
	assert(pphead);
	​SLTNode* pcur = *pphead;
	while (pcur)
	{
		​SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//*pphead是野指针，要置为空
	*pphead = NULL;
}
（3）test.c：
#define  _CRT_SECURE_NO_WARNINGS  1

#include"SList.h"

int test01()
{
	//创建一个链表——实际上是创建一个一个节点，再把节点连起来
	​SLTNode*node1=(​SLTNode*)malloc(sizeof(​SLTNode));
	​SLTNode*node2=(​SLTNode*)malloc(sizeof(​SLTNode));
	​SLTNode*node3=(​SLTNode*)malloc(sizeof(​SLTNode));
	​SLTNode*node4=(​SLTNode*)malloc(sizeof(​SLTNode));

	node1->data = 1;
	node2->data = 2;
	node3->data = 3;
	node4->data = 4;

	node1->next = node2;
	node2->next = node3;
	node3->next = node4;
	node4->next = NULL;

	​SLTNode* plist = node1;
	//打印链表
	SLTPrint(plist);
}

void test02()
{
	//创建空链表
	​SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);
	////SLTPushFront(&plist, 1);
	//SLTPrint(plist);
	//SLTPushFront(&plist, 2);
	//SLTPrint(plist);
	//SLTPushFront(&plist, 3);
	//SLTPrint(plist);
	//SLTPushFront(&plist, 4);
	//SLTPrint(plist);

	////SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);

////头删
//	SLTPopFront(&plist);
//	SLTPrint(plist);
//	SLTPopFront(&plist);
//	SLTPrint(plist);
//	SLTPopFront(&plist);
//	SLTPrint(plist);
//	SLTPopFront(&plist);
//	SLTPrint(plist);
	​SLTNode* pos = SLTFind(plist, 3);
	//if (pos)
	//{
	//	printf("找到了！\n");
	//}
	//else
	//{
	//	printf("未找到！\n");
	//}
	//SLTInsert(&plist, pos, 100);
	/*SLTInsertAfter(pos, 100);*/
	//SLTErase(&plist, pos);
	//SLTPrint(plist);

	SListDestory(&plist);
}

int main()
{
	/*test01();*/
	test02();
	return 0;
}

结尾

往期回顾：

【数据结构与算法】数据结构初阶：详解顺序表和链表（三）——单链表（上

本期内容需要回顾的C语言知识如下面的截图中所示（指针博主写了6篇，列出来有水字数嫌疑了，就只放指针第六篇的网址，博主在指针（六）把指针部分的前五篇的网址都放在【往期回顾】了，点击【传送门】就可以看了）。

大家如果对前面部分的知识点印象不深，可以去上一篇文章的结尾部分看看，博主把需要回顾的知识点相关的博客的链接都放在上一篇文章了，上一篇文章的链接博主放在下面了：

 【数据结构与算法】数据结构初阶：详解顺序表和链表（三）——单链表（上）

结语：本篇文章到这里就结束了，对数据结构的单链表知识感兴趣的友友们可以在评论区留言，博主创作时可能存在笔误，或者知识点不严谨的地方，大家多担待，如果大家在阅读的时候发现了行文有什么错误欢迎在评论区斧正，再次感谢友友们的关注和支持！

初阶数据结构之顺序表详解
2302_80837091的博客
04-26 935
线性表的长度，即所含元素的个数，用n表示，且n可以等于零，表示线性表是一个空表。此外，线性表可以是有序的，也可以是无序的。另外，声明也允许将程序的不同部分分开编译，因为在一个文件中声明了一个变量或函数后，在其他文件中可以使用这个声明而无需重新定义。实现动态顺序表的实现之前我们需要创建2个源文件分别进行顺序表功能的实现和功能的测试，和一个头文件用于函数的声明和顺序表的创建。数据结构的研究还涉及到为这种结构定义适当的运算，并设计出相应的算法，确保经过这些运算后得到的新结构仍保持原来的结构类型。
链队列在队头插入元素c语言,数据结构实验5_C语言_链队列的基本操作、入队、出队、获取队头元...
weixin_29224589的博客
05-25 2316
数据结构实验5_C语言_链队列的基本操作、入队、出队、获取队头元数据结构实验5_C语言_链队列的基本操作、入队、出队、获取队头元素等实验5、链队列的基本操作(1)实验目的通过该实验，使学生理解链队列的构造特点并灵活应用，掌握链队基本操作的编程实现，认识栈是在一端进行插入，在另一端进行删除集中操作的线性结构，掌握队列的“先入先出”操作特点，知道判断队列空和满的条件，进一步熟悉C语言中指针操作。(2)...
【数据结构与算法】数据结构初阶：详解顺序表和链表（三）——单链表（上）
2401_89899187的博客
07-11 976
前言：本篇文章，我们复盘顺序表和链表相关的知识点，在初阶的数据结构与算法阶段，我们把知识点分成三部分，复杂度作为第一部分，顺序表和链表、栈和队列、二叉树为第二部分，排序为第二部分，我们之前已经介绍完了第一部分：算法复杂度，本文我们继续学习第二部分中的顺序表和链表部分内容啦。半个多月前，博主更新了头插、尾删、头删、随机位置插入、随机位置删除、查找、修改、菜单等内容，本篇文章，我们就来复盘一下动态顺序表的内容，博主会添加很多新内容，希望对大家的顺序表学习有所帮助。
【数据结构与算法】数据结构初阶：详解顺序表和链表（一）
2401_89899187的博客
06-22 1160
🔥前言：上篇文章我们介绍了复杂度的概念，我们通过一个个经典的例子 ，对时间复杂度和空间复杂度的概念进行了剖析，结合图像，让大家更加直观地理解知识点，我们对比了常见的复杂度，展示了各种各样的排序算法的复杂度表格，通过轮转数组这一道力扣题向大家展示了“算法思路有很多种”名不虚传，我们通过三种不同的思路（超出时间限制、通过、时间复杂度O(n)空间复杂度O(1)的情况下通过）详解了算法和复杂度的关系。
【数据结构与算法】数据结构初阶：详解顺序表和链表（二）
2401_89899187的博客
06-24 1361
前言：本篇文章，我们继续介绍顺序表和链表相关的知识点，在初阶的数据结构与算法阶段，我们把知识点分成三部分，复杂度作为第一部分，顺序表和链表、栈和队列、二叉树为第二部分，排序为第二部分，我们之前已经介绍完了第一部分：算法复杂度，本文我们继续学习第二部分中的顺序表和链表部分内容啦。
【数据结构初阶-线性表】顺序表和链表，多图详解
BaconZzz的博客
08-10 1783
细细咀嚼...
【数据结构与算法】数据结构初阶：动态顺序表各种方法（接口函数）复盘与整理
2401_89899187的博客
07-10 1309
本篇文章，我们复盘顺序表和链表相关的知识点，在初阶的数据结构与算法阶段，我们把知识点分成三部分，复杂度作为第一部分，顺序表和链表、栈和队列、二叉树为第二部分，排序为第二部分，我们之前已经介绍完了第一部分：算法复杂度，本文我们继续学习第二部分中的顺序表和链表部分内容啦。半个多月前，博主更新了头插、尾删、头删、随机位置插入、随机位置删除、查找、修改、菜单等内容，本篇文章，我们就来复盘一下动态顺序表的内容，博主会添加很多新内容，希望对大家的顺序表学习有所帮助。
数据结构初阶--顺序表和链表
weixin_67916525的博客
02-19 565
顺序表本质上就是数组。但是在此之上，顺序表要求存储的数据必须是连续紧挨着的，不能跳跃。用一段物理地址连续的存储单元依次存储数据元素的线性结构。线性表在逻辑上是线性结构，也就说是连续的一条直线。顺序表的物理结构和逻辑结构是一致的。链表是用指针把一块一块内存链接起来。
【数据结构初阶(第五节)】单链表经典算法题十道（详解+图例）—得道飞升（上篇）
稻草人
07-26 1716
创建一个新链表，newhead，newtail 指向新链表的头结点，定义两个指针分别指向原链表的头结点，两个指针指向的数据比较大小，谁小谁尾插到新链表里面。在实例中，最后一个5结点被尾插到新链表中时，5结点的next指针指向的仍然是后面的6结点，所以最后返回的时候结果里面含有6，所以我们把最后一个等于val结点的next指针指向NULL即可！慢指针每次走一步，快指针每次走两步，当快指针走到链表的尾结点时，假设链表的长度为n，快指针走的路程是慢指针的两倍，2*慢=快，即慢指针走的路程是n/2。
【初阶数据结构与算法】第四篇：链表面试题详解
YQ20210216的博客
03-21 1891
⭐️本篇博客我要给大家分享一下算法中的链表例题。希望对大家有所帮助。 ⭐️ 博主码云gitee链接：码云主页 前言 ​ 🌏一、移除链表元素（传送门） 🍤给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5] 🔑思路： struct L...
【初阶数据结构】——顺序表详解（C描述）
m0_70980326的博客
11-01 1222
顺序表详解 及 增删查改各接口函数实现
C语言初阶与进阶教程：基础知识详解
进阶内容通常涉及更深层次的编程概念和技巧，如内存管理、文件操作、数据结构、算法实现等。 - **内存管理**：使用动态内存分配函数malloc、calloc、realloc和free。 - **文件操作**：使用文件I/O函数进行文件的读写...
【打造STC89C52单片机第一应用】：项目实战全攻略
文章首先概述了STC89C52的引脚功能和基础特性，紧接着详细阐述了硬件连接和外围模块的接入方法，包括LED、按键和显示模块的配置。在此基础上，文中进一步探讨了电源管理、信号调理技术以及Keil C51开发环境的配置与...
C++后台开发学习路线
qq_42066648的博客
03-02 3233
C++后台开发学习路线 2.1 如何拿下BAT：我的学习路线 前言 **2019年对我而言必定是人生当中最重要的一年。因为实习的原因，我第一次体验了北京和上海的生活，匆匆且忙碌。这一年生活当中充斥着各种求职咨询，面试，做题，仿佛一夜回到了高三。不过，我是幸运的。从寒假实习开始到暑假实习再到秋招，一路以来我并没有体会到太多的挫折，一路高歌，最终也收获了我自己认为还不错的offer。也许是因为运气，也许是因为坚持，但是硕士这2年来我也经历了种种心酸和波折。我起初走过很多弯路，在无数个深夜里苦恼自己的无知和弱小，
【数据结构】图 ，拓扑排序 未完
最新发布
oDianZi1234567的博客
07-14 317
参考：AB13 【模板】拓扑排序。
数据结构——深度优先搜索与广度优先搜索的实现
2401_88020079的博客
07-09 418
好了，温习过基础深度遍历方法后，我们来介绍广度优先遍历，所谓广度优先遍历就是一层一层的遍历，不再追求走到叶子结点，而是从左到右一步步走完，所以，广度优先遍历多被用于寻找最短路的题目中。好了，介绍完深度优先遍历与广度优先遍历的写法后，我们还有一个拓展知识点——仔细思考一下，如果使用深度优先遍历，如果层数太多我们在写一个搜索时会时常遇到加载慢的问题，而如果我们使用记忆化搜索，随着数据量的增多，不免会积累海量的数据。————————————本栏目旨在交流计算机知识，欢迎交流指正！
终极剖析HashMap：数据结构、哈希冲突与解决方案全解
yiridancan的博客
07-13 618
优秀的工程设计是在数学理论与硬件特性间寻找平衡点。HashMap的成功在于它用分层防御体系将冲突概率降到最低，用尾插法+红黑树解决了链地址法的固有缺陷，最终成就了Java集合框架中最璀璨的明珠。
Redis底层数据结构
qinwenjng120的博客
07-11 1119
通过添加的这些参数，可以更方便解析字符串。例如，如果用数组方式保存字符串，那么读取完整字符串就只能遍历数组里的各个字节数据，时间复杂度O(N)。但是SDS中预先记录了len后，就可以直接读取一定长度的字节，时间复杂度O(1)，效率更高。另外，C语言中通常用字节数组保存字符串，那么还需要定义一个特殊的结束符\0表示这一个字符串结束。但是在Redis中，如果value中就包含\0这样的字符串，就会产生歧义。根据不同的键值，选择不同的编码方式（不同的底层数据结构）， int | embstr | raw。
map数据结构在Golang中是无序的，并且键值对的查找效率较高的原因
Gaorui678的博客
07-11 192
map，map在Go语言中是无序的，是因为在Go语言中，map基于哈希表实现，它的遍历顺序依赖于哈希表内部存储状态，对并发编程的潜在影响包括可能引发数据一致性问题，也就是并发度写实易导致读到不一样的数据或遍历出错；（4）动态扩容，当负载因子（键值对数量/桶数量）超过阈值时，map会自动扩容，减少哈希冲突概率，维持O(1)的平均操作时间。（2）哈希表的函数优化，Go会根据键的类型选择高效的哈希函数，均匀分布键以减少冲突。（1）哈希表的时间复杂度，哈希表的平均复杂度为O（1），最欢情况下为O（n）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值