【数据结构详解】——线性表之单链表（动图详解）

于 2022-08-05 22:15:40 发布
阅读量416 收藏 3
点赞数 3
分类专栏： 数据结构详解 文章标签： 数据结构 链表 算法 经验分享 c语言
❗ 转载请注明出处 作者：HinsCoder 博客链接：
本文链接：https://blog.csdn.net/HinsCoder/article/details/126163572
版权

前言：本期我们将讨论线性表另外一种存储结构————链式存储结构，相比顺序表互有优劣，我们不能片面的认为链表优势大于顺序表，两种存储方式都应该熟知并掌握。

目录

1. 链表

1.1 链表的概念及结构

  • 链表是一种物理存储结构上非连续、非顺序的存储结构。
  • 数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
  • 链表也是线性表的其中一种。

小结：链表是逻辑结构上类似于顺序表的连续的结构，但实际物理结构是不一定连续存储的。

接下来我们展开说说：

在这里插入图片描述
由上图我们可知：

  1. 链表实际上是由不同的结点链接而成的（结点是由结构体类型来创建而成的）

  2. 结点是由数据域data（存放数据）和指针域next（存放下一个结点的地址）所组成的

  3. 结点一般是在堆上申请空间的（申请的空间的地址在堆区上是随机分配的，即空间的地址是随机的，这也是为什么每个结点的地址不一定连续），因此不能像顺序表进行下标访问

简而言之：

  • 链表的元素之间的访问并不像顺序表可以通过下标进行随机访问，而是通过访问每个结点的指针域（指针域内存储了下一个结点的空间地址），即通过访问下一个结点的地址，去找到下一个结点。
  • 链表是由一个个结点的指针域里的地址链接起来的，其中元素之间的空间地址并不连续，所以不能像顺序表进行下标访问，这也是为什么链表的逻辑结构与物理结构不同

1.2 单链表的概念

由N个结点组成的就叫做链表，在此基础上由一个指针链接起来的就叫做单链表，后续还会有双链表…单向不带头链表…等等。
在这里插入图片描述

如上图，整个链表的的存取打印必须从头指针开始进行，头指针表示链表中第一个结点（即第一个数据元素的地址）的存储位置，这里的头指针就是phead/plist， 由于最后一个数据元素没有直接后续，又为了方便链接新节点，所以链表最后一个结点的指针为“空”（NULL）。

有了以上对链表的概念后，我们便可以实现它啦~

2. 单链表的接口实现

对于数据结构的接口实现，一般围绕着增、删、查、改的内容

typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;		//存储数据
	struct SListNode* next;	//指向下一个结点的地址
}SLTNode;

注意：

typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
	//SLTNode* next;    //下面这两种写法都是错的哦
	//SListNode* next;
}SLTNode,*PSLTNode; 	//（SLTNode是SListNode的重定义；*PSLTNode是struct SListNode的重定义）
  • 链表可以根据存储的数据多少实现随时创建结点（动态开辟）进行链接，不会存在空间的浪费

接下来我们实现动态顺序表的各接口函数，此处我们实现的是基础的单向不带头不循环链表。

2.1 创建新结点

思路：像顺序表的空间开辟，与插入函数类似，直接看代码

SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode)); // 动态申请一个空间
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;	// 将新数据放到结构体的数据域中
	newnode->next = NULL;// 链接下一个结点

	return newnode;
}

2.2 打印单链表

思路：打印这个链表并不需要对链表进行存取，所以形参部分就直接用一级指针就行了。定义一个结构体指针cur，让cur指向这个链表的头指针（也就是指向这个链表的起始位置）。
用cur这个指针去遍历这个数组并打印

2.3 初始化单链表

单链表结构非常简单，不需要初始化

SLTNode* plist = NULL

这样就表示一个单链表了

2.4 头插单链表

思路：新申请一个结点，将新结点的newnode->next用来存放头指针（pphead）的地址，再让头指针（pphead）指向的位置改变为新结点（newnode）

观察下面代码，先思考一下这样创建新结点是否可行？

SLTNode newnode;
显然是不行的，因为是局部变量，出了作用域这个结点就销毁了。

单链表头插动画

void SListPushFront(SLTNode* phead, SLTDataType x)
{
	SLTNode* newnode = BuySLTNode(x);	//把新结点申请出来
	newnode->next = phead;				//让新结点的next指向第一个老结点的phead
	phead = newnode;					//把新申请的结点的地址再重新放到phead上
}

如果你是按照上面这个方式写代码，那可就要出事了，因为犯了一个经典错误。
在这里插入图片描述

打开调试窗口开一下，诶，似乎已经正确插入了呀，别急，打印看一下。
在这里插入图片描述

出问题了，怎么打印出NULL了？刚刚不是存进去了吗？
我们结合栈帧的知识讲解一下，不了解栈帧的朋友可以看一看【C语言详解】——函数栈帧的创建与销毁（动图详解）这篇文章哦~
在这里插入图片描述
那有朋友就要问了，传参传的不是指针吗，为什么也无效呢？
其实，传指针要解引用的，上面的代码就是没有解引用。

举个例子：

void swapi(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}

int main()
{
	int x = 0, y = 1;
	swapi(&x, &y);

	int* p1 = &x, *p2 = &y;
	swapi(p1, p2);

	return 0;
}

交换函数传递指针问题动画

注意看动图，好像x,y值变了，再仔细看，诶，好像它俩的地址没变，指向的值倒是变了。可是，我们的任务是交换指针来着，问题就出在这里了。
这时候，就要请出我们的二级指针了。

void swapptr(int** ppx, int** ppy)
{
	int* tmp = *ppx;
	*ppx = *ppy;
	*ppy = tmp;
}

交换函数传递二级指针问题动画
所以，平时我们传内容，用一级指针就足矣，但我们这次要传指针，就要用到指针的指针，即传二级指针过去，然后二级指针解引用。
小结：要改变谁，就传谁的地址。

单链表头插函数传递二级指针动画

正确代码：

void SListPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	SLTNode* newnode = BuySLTNode(x);	//把新结点申请出来
	newnode->next = *pphead;			//让新结点的next指向第一个老结点的pphead
	*pphead = newnode;					//把新申请的结点的地址再重新放到pphead上
}

注意： newnode->next = *pphead; 和
*pphead = newnode; 这两条语句千万不要弄反了，否则就会丢失下一个结点的地址了。

2.5 尾插单链表

思路：进行尾插第一步先申请一个新结点，之后需要判断链表是否为空，如果是空直接将新开辟的结点连到头结点pphead即可，如果不为空就用一个指针找到尾结点，然后链接新结点。
在这里插入图片描述
在SListPrint中我们知道，链表有可能为空，那么在SListPushBack中传过来的pphead有可能为空吗？

其实，是不可能为空的。

pphead是plist的地址，也就意味着plist为空，但pphead永远不可能为空，因此记得断言哦~

void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	SLTNode* newnode = BuySLTNode(x);

	// 1、空
	// 2、非空
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		// 找尾
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		tail->next = newnode;
	}
}

2.6 头删单链表

思路：先判断是否为空，不为空则创建一个del结点，把第一个结点的地址传给它，然后头指针指向下一个结点，free释放掉del即可。这种思路也很好的兼顾了只有一个结点的情况。

请添加图片描述

void SListPopFront(SLTNode** pphead)
{
	assert(pphead);
	// 为空不能删
	// 温柔的检查
	if (*pphead == NULL)
	{
		return;
	}

	// 暴力的检查
	//assert(*pphead != NULL);	//c++库里都是暴力的检查哦~

	SLTNode* del = *pphead;
	*pphead = (*pphead)->next;	//优先级记得加括号
	free(del);
	del = NULL;	//好习惯不写无所谓
}

2.7 尾删单链表

思路：先判断是否为空，不为空则区分两种情况，一个结点和多个结点，找尾后释放。

首先观察一下下面这段找尾代码可行吗？

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	
	if (*pphead == NULL)
	{
		return;
	}
	
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		// 找尾
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		free(tail);
	}
}

上面这段代码就是经典的野指针问题。
在这里插入图片描述
解决方式就是，需要两个指针，一个向前跑，一个在后面记录上一个结点的地址。
单链表尾删函数方式1动画

		// 找尾
		SLTNode* prev = NULL;
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}

		prev->next = NULL;
		free(tail);
		tail = NULL;

还有一种解决方式：
单链表尾删函数方式2动画

		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}

		free(tail->next);
		tail->next = NULL;

完整代码：

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);

	// 温柔的检查
	/*if (*pphead == NULL)
		return;
	*/
	
	// 暴力检查
	assert(*pphead != NULL);
	
	if ((*pphead)->next == NULL)	// 1、一个节点
	{
		free(*pphead);
		*pphead = NULL;
	}
	else	// 2、多个节点
	{
		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}

		free(tail->next);
		tail->next = NULL;
	}
}

2.8 查找单链表结点

思路：遍历链表找结点，并返回地址。

SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}

		cur = cur->next;
	}

	return NULL;
}

其中，我们也发现查找函数同样可以用来修改结点，我们可以在main函数直接设置。

	//test.c
	SLTNode* pos = SListFind(plist, 3);
	if (pos)
	{
		// 修改
		pos->data *= 10;
		printf("找到了\n");
	}
	else
	{
		printf("没有找到\n");
	}
	SListPrint(plist);

在这里插入图片描述

2.9 销毁单链表

思路：逐一遍历链表结点，然后逐个释放。

请添加图片描述

void SListDestory(SLTNode** pphead)
{
	assert(pphead);

	SLTNode* cur = *pphead;
	//while (cur != NULL)
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}

	*pphead = NULL;
}

2.10 任意位置前插入结点

思路：找到pos的位置，然后将待插入的结点链接到链表上。

我们可以在main函数里和find函数配合一下

	// test.c
	pos = SListFind(plist, 2);
	if (pos)
	{
		SListInsert(&plist, pos, 20);
	}
	SListPrint(plist);

单链表任意位置前插入函数动画

// 在pos之前插入
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);

	if (pos == *pphead)	//头插
	{
		SListPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;

			// 暴力检查，pos不在链表中.prev为空，还没有找到pos，说明pos传错了
			assert(prev);
		}

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

2.11 任意位置后插入结点

思路：找到pos的位置，然后将待插入的结点链接到链表上。

单链表任意位置后插入函数动画

void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

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

2.12 删除任意位置结点

思路：找到待删除数据的位置，将pos上下两个结点链接起来，释放掉待删除数据。
单链表任意位置删除函数动画

// 删除pos位置
void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);

	if (*pphead == pos)
	{
		SListPopFront(pphead);	//头删
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
			// 检查pos不是链表中的节点，参数传错了
			assert(prev);
		}

		prev->next = pos->next;
		free(pos);
		//pos = NULL;
	}
}

2.13 删除任意位置后一个结点

思路：找到待删除数据的位置，将pos->next上下两个结点链接起来，释放掉待删除数据。注意不能对最后一个结点后删。

单链表任意位置后一个结点删除函数动画

// 删除pos后面位置
void SListEraseAfter(SLTNode* pos)
{
	assert(pos);

	if (pos->next == NULL)
	{
		return;
	}
	else
	{
		SLTNode* next = pos->next;
		pos->next = next->next;
		free(next);
	}
}

3. 单链表的优缺点

优点：

  • 头插头删时间复杂度为O(1)
  • 空间按需分配，不容易浪费

缺点：

  • 不支持随机访问
  • 相比顺序表的数组存储，多了个指针域存储，需要的空间更大。

4. 完整源码

// SList.h
#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<stdio.h>
#include<assert.h>

typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;		//存储数据
	struct SListNode* next;	//指向下一个结点的地址
	//SLTNode* next;  不可以这样
	//SListNode* next;
}SLTNode;
//}SLTNode,*PSLTNode; （SLTNode是SListNode的重定义；*PSLTNode是struct SListNode的重定义）


void SListPrint(SLTNode* phead);	//等价于void SListPrint( PSLTNode phead);

SLTNode* BuySLTNode(SLTDataType x);

void SListDestory(SLTNode** pphead);
void SListPushFront(SLTNode** pphead, SLTDataType x);
void SListPushBack(SLTNode** pphead, SLTDataType x);
void SListPopBack(SLTNode** pphead);
void SListPopFront(SLTNode** pphead);

SLTNode* SListFind(SLTNode* phead, SLTDataType x);

// 在pos之前插入
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

// 在pos后面插入
void SListInsertAfter(SLTNode* pos, SLTDataType x);

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

// 删除pos后面位置
void SListEraseAfter(SLTNode* pos);


// SList.c
#include"SList.h"

void SListPrint(SLTNode* phead)	//遍历打印
{
	//不用断言哦，因为链表为空是正常情况
	SLTNode* cur = phead;	//cur是指向这个链表的指针

	while (cur != NULL)
	{
		printf("%d->", cur->data);	//打印数据	
		cur = cur->next;			//然后指向下一个结点，然后循环判断并继续打印
	}
	printf("NULL\n");
}

SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode)); // 动态申请一个空间
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;	// 将新数据放到结构体的数据域中
	newnode->next = NULL;// 链接下一个结点

	return newnode;
}

void SListDestory(SLTNode** pphead)
{
	assert(pphead);

	SLTNode* cur = *pphead;
	//while (cur != NULL)
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}

	*pphead = NULL;
}

void SListPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	SLTNode* newnode = BuySLTNode(x);				//把新结点申请出来
	newnode->next = *pphead;						//让新结点的next指向第一个老结点的pphead
	*pphead = newnode;								//把新申请的结点的地址再重新放到pphead上
}

void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	SLTNode* newnode = BuySLTNode(x);

	// 1、空
	// 2、非空
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		// 找尾
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		tail->next = newnode;
	}
}

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);

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

	// 暴力检查
	//assert(*pphead != NULL);


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

		prev->next = NULL;
		free(tail);
		tail = NULL;*/

		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}

		free(tail->next);
		tail->next = NULL;
	}
}

void SListPopFront(SLTNode** pphead)
{
	assert(pphead);

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

	// 暴力的检查
	//assert(*pphead != NULL);

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

SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}

		cur = cur->next;
	}

	return NULL;
}

// 在pos之前插入
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);

	if (pos == *pphead)
	{
		SListPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;

			// 暴力检查，pos不在链表中.prev为空，还没有找到pos，说明pos传错了
			assert(prev);
		}

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

// 在pos后面插入
void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

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

// 删除pos位置
void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);

	if (*pphead == pos)
	{
		SListPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
			// 检查pos不是链表中的节点，参数传错了
			assert(prev);
		}

		prev->next = pos->next;
		free(pos);
		//pos = NULL;
	}
}

// 删除pos后面位置
void SListEraseAfter(SLTNode* pos)
{
	assert(pos);

	if (pos->next == NULL)
	{
		return;
	}
	else
	{
		SLTNode* next = pos->next;
		pos->next = next->next;
		free(next);
	}
}


// test.c
#include"SList.h"
void TestSList1()
{
	SLTNode* plist = NULL;
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPushFront(&plist, 4);

	SListPrint(plist);
	/*
	SListPopFront(&plist);
	SListPrint(plist);
	SListPopFront(&plist);
	SListPrint(plist);
	SListPopFront(&plist);
	SListPrint(plist);
	SListPopFront(&plist);
	SListPrint(plist);

	SListPopFront(&plist);
	SListPrint(plist);

	SListDestory(&plist);
	*/
}

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

	SListPopBack(&plist);
	SListPrint(plist);
	/*
	SListPopBack(&plist);
	SListPrint(plist);
	SListPopBack(&plist);
	SListPrint(plist);
	SListPopBack(&plist);
	SListPrint(plist);

	SListPopBack(&plist);
	SListPrint(plist);

	SListDestory(&plist);
	*/
}


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

	SLTNode* pos = SListFind(plist, 3);
	if (pos)
	{
		// 修改
		pos->data *= 10;
		printf("找到了\n");
	}
	else
	{
		printf("没有找到\n");
	}
	SListPrint(plist);
	
	pos = SListFind(plist, 2);
	if (pos)
	{
		SListInsert(&plist, pos, 20);
	}
	SListPrint(plist);

	pos = SListFind(plist, 1);
	if (pos)
	{
		SListInsert(&plist, pos, 10);
	}
	SListPrint(plist);

	SListDestory(&plist);
	
}

void TestSList4()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPrint(plist);

	SLTNode* pos = SListFind(plist, 3);
	if (pos)
	{
		SListErase(&plist, pos);
		pos = NULL;
	}
	SListPrint(plist);

	pos = SListFind(plist, 1);
	if (pos)
	{
		SListErase(&plist, pos);
		pos = NULL;
	}
	SListPrint(plist);


}

int main()
{
	TestSList3();
	//TestSList4();

	return 0;
}

//void swapi(int* px, int* py)
//{
//	int tmp = *px;
//	*px = *py;
//	*py = tmp;
//}
//
//void swapptr(int** ppx, int** ppy)
//{
//	int* tmp = *ppx;
//	*ppx = *ppy;
//	*ppy = tmp;
//}
//
//int main()
//{
//	int x = 0, y = 1;
//	swapi(&x, &y);
//
//	int* p1 = &x, *p2 = &y;
//	swapi(p1, p2);
//
//	swapptr(&p1, &p2);
//
//	return 0;
//}

OK，以上就是本期知识点“单链表”的知识啦~~ ，感谢友友们的阅读。后续还会继续更新，欢迎持续关注哟~
如果觉得收获满满，可以点点赞👍支持一下哟~

HinsCoder
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之链表-动图演示
HuaZi_Myth的博客
11-12 669
链表简介 链表是很常见的数据结构，由一个个节点组成，每个节点中储存着数据和指针(地址引用)，指针负责节点间的连接。 它是一种线性表，线性表有两种存储方式：顺序存储和链式存储。链表属于链式存储，顺序由元素间的指针决定，元素在内存中非连续存放，且链表长度可以改变。数组是顺序存储的线性表，元素在内存中连续存放的，且数组创建时大小已固定。 链表可以用来实现栈和队列数据结构(栈和队列可理解为逻辑类数据...
数据结构实验——线性表子系统
07-31
线性表是数据结构中最基础且重要的概念之一，它是由n(n≥0)个相同类型元素组成的有限序列。在这个实验中，我们主要关注线性表的链式存储结构，特别是字符型的单链表。实验的目标是理解线性表的特点，掌握顺序存储和...
数据结构---->线性表
weixin_34417183的博客
11-08 154
线性表 一、线性表抽象数据类型 1.1、定义 线性表是指n (n&gt;=0)个相同类型的数据元素a0,a1,...an-1所构成的有限线性序列，其一般描述为：LinearList=(a0，a1，…，an－1) 1) 其中LinearList称为线性表的名称 2) 每个ai（n-1≥i≥0）称为线性表的数据元素，可以是整数、浮点数、字符或类 3) 表中相邻元素之间存在着顺序关系：将ai...
数据结构——动态链表（GIF图解）
weixin_43294413的博客
12-19 6997
一、链表的定义 为了表示每个数据元素a1与其直接后继元素ai+1之间的逻辑关系，对数据元素a1来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息。我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域存储的信息称作链。这两部分信息组成数据元素ai的存储映像，称为结点。 n个结点链结成一个链表，即为线性表的链式存储结构，因为此链表的每个结点中只包含一个指针域，所...
【玩转链表①】单链表动图图解（超详解）
罅隙的博客
03-17 3646
全网最全面细致的单链表讲解
＜数据结构＞刷题笔记——链表篇（一）（有动图详解）
qq_47882731的博客
03-22 2375
力扣203. 移除链表元素 struct ListNode* removeElements(struct ListNode* head, int val){ struct ListNode* prev = NULL; struct ListNode* cur = head; while(cur) { if(cur->val == val) { struct ListNode* next = cur->nex
数据结构---线性表之单链表（C语言）
03-28
单链表是数据结构中的一种基础类型，尤其在C语言编程中经常被使用。它是一种线性的、非连续的数据组织形式，每个元素称为节点，每个节点包含数据和一个指向下一个节点的指针。本篇文章将深入探讨单链表的创建、插入...
数据结构——线性表
02-06
另外还实现了简单单链表、简单顺序线性表、从A链表中删除B和C链表共有的元素、单链表逆置（以整数为例）、将链表中元素按递增排序并删除所选定范围内的元素、求一个新的集合A为A和B的交集（采用单链表作为存储结构）...
数据结构c版（1）-线性表之单链表代码
最新发布
11-19
在这个“数据结构C版（1）-线性表之单链表代码”中，我们将深入探讨线性表这一基础数据结构的C语言实现，特别是单链表。 单链表是一种线性数据结构，其中的元素并非在内存中连续存储，而是通过指针连接。每个元素...
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
12-02
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc 知识点摘要： 1. 数据结构的基本概念：数据结构是计算机科学中的一种基本概念，指的是数据的组织和存储方式。 2. 线性表的概念：线性表是一种基本...
数据结构中的链表、树、图等代码＋动态演示系统
09-24
数据结构中的如何构建链表、树等动态演示，以及一些经典的算法，比如八皇后，迷宫，汉诺塔等右边是代码单步执行，左边是动态演示，直观，易理解，易学。。。
数据结构——线性表的实现.zip
09-18
线性表是数据结构中最基础且重要的概念之一，它是由n（n≥0）个相同类型元素构成的有限序列。在线性表中，元素之间的逻辑关系是一对一的关系，即每个元素都有一个前驱元素和一个后继元素，只有第一个元素没有前驱，...
数据结构实验——线性表的插入、删除.docx
06-13
数据结构实验报告——线性表的插入、删除 在计算机科学领域中，数据结构是一种组织和存储数据的方式，以便更高效地使用计算机资源。线性表是一种基本的数据结构，广泛应用于各种计算机应用程序中。线性表的插入和...
数据结构实验报告——线性表.pdf
11-12
《数据结构实验报告——线性表》探讨了在互联网领域中数据结构的基础应用，特别是针对线性表这一重要概念。线性表是一种基础的数据结构，它由有限个相同类型元素构成的有序序列。本实验报告详细阐述了如何利用C++...
＜数据结构＞刷题笔记——链表篇（二）（有动图详解）
qq_47882731的博客
03-27 1226
876. 链表的中间结点 struct ListNode* middleNode(struct ListNode* head){ struct ListNode* fast,*slow; fast = slow = head; while(fast && fast->next) { slow = slow->next; fast = fast->next->next; } return s
java链表面试题总结（附动图详解）
weixin_42738587的博客
09-13 336
1.输出单链表中倒数第k个节点 第一种解法：定义两个变量p、q指向头结点，p先向前走k-1步，之后p、q同时向后走，直到q.next=null，此时p指向的就是倒数第k个节点。（或者p先向前走k步，之后p、q同时向后走，直到q=null） 代码如下 private int getLength() { int length = 0; for (Entry<T> p = ...
【数据结构初阶】第三篇——单链表（实现+动图演示）
weixin_58450087的博客
10-21 1349
上一篇博客我已经分享了顺序表的相关内容，这一篇博客，我又要来介绍一下单链表有关内容。 目录链表的概念链表的实现链表的结构定义 链表的概念 概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 链表大概有这么三种，今天我主要给大家介绍第一种——单链表，下一篇博客我会给大家介绍双链表的有关内容。 值得注意的是： 1.从图中可知，链表的在逻辑是连续的，物理上不一定是连续的； 2.现实中节点是从堆上申请的。 链表的实现 链表的结构定义 ...
Java数据结构之图解单链表 + 单链表实例
李思成的博客
06-03 842
链表（Linked List）介绍： 1，链表是以节点的方式来存储是链式存储 2，每个节包含 data域：存储信息next域：指向下一个节点。 3，链表的各个节点不一定是连续存储的。 4，链表分带头结点的链表和没有头节点的链表，根据实际情况来确定 链表在内存中的存储形式： 由此得出：链表的各个节点不一定是连续存储的。 单链表的逻辑结构示意图： 每一个节点Node中都包含一个data域和一个指针域。 链表的操作图解： 创建链表： 1、头插法：把后建立的结点插在头部。用...
数据结构实验：线性表与单链表逆置
"这份文档是鞍山师范学院数学与信息科学学院的数据结构实验说明书，主要针对2021年的课程。实验旨在让学生熟悉线性表在两种存储结构（顺序表和链表）上的基本操作，特别是链表的操作和应用。实验包括两个部分：顺序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值