链表基础学习

最新推荐文章于 2024-09-26 17:12:37 发布
最新推荐文章于 2024-09-26 17:12:37 发布
阅读量101 收藏
点赞数 1
文章标签： 链表 学习 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_72540891/article/details/133918395
版权

链表的基本定义：

        链表是一种数据结构，用于存储和组织数据。它由一系列称为结点的元素组成，每个结点包含数据和一个指向下一个结点的指针。结点通过指针的链接顺序连接在一起，形成一个链式结构。

        与数组不同，链表的元素在内存中不是连续存放的，而是通过指针相互连接。这种特性使得链表具有动态性，可以在运行时快速地插入和删除元素，而无需移动其他元素。

        链表可以分为单向链表和双向链表。单向链表中，每个结点只有一个指向下一个结点的指针；双向链表中，每个结点既有一个指向下一个结点的指针，又有一个指向前一个结点的指针。

链表的组成：

        链表的基本单位是结点，链表的结点一般由两个域组成：数据域（data filed）和指针域（pointer filed）。

        1、数据域：存储链表所持有的数据。它可以是任意类型的数据，如整形、字符、对象等，根据实际需求而定。

        2、指针域：指针域存储指向下一个结点（或上一个结点，如果是双向链表）的指针。它保存了连接结点之间关系的信息，使得链表能够按顺序访问各个结点。如果指针为 null（空指针），表示没有下一个结点，链表在此处结束。

链表的构造：

        数据结构的基本单位一般由结构体来构造完成，这里分别用两个不同的结构体来构造链表的结点和链表本身。

        1、结点定义：data指向数据域，*next指向下一个结点

typedef struct node
{
    int data;
    struct node* next;
}Node;

        2、单链表定义：head指向头结点，end指向尾结点，length为链表的长度

typedef struct linklist
{
    Node* head;
    Node* end;
    int length;
}LL;

链表功能的实现：

        如今链表的基本单位已经构造完成，下面开始实现单链表的基本功能。

        先定义单链表的基本功能函数。

        下面是单链表的功能函数头文件 linklist.h。

//linklist.h
//用C语言实现单链表基本功能
#pragma once

#ifndef LINKLIST
#define LINKLIST

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

typedef int Type;//数据域的数据类型
#define TYPE_P "%d->"
#define TYPE_S "%d"

typedef struct node{
	Type data;
	struct node * next;
}Node;

typedef struct linklist{
	Node *head;
	Node *end;
	int length;
}LL;

//1.单链表的创建
LL* list_init();//链表的初始化函数

//链表结点的初始化函数
Node* node_init(Type val);

//2.单链表数据的结点插入
//①向单链表尾部插入数据（尾插）
void list_insert_end(LL* list, Type val);

//②向单链表指定位置插入数据
void list_insert(LL* list, Type val, int index);

//3.单链表结点的删除，并返回删除的数据
Type list_delete_Node(LL* list, int index);//根据位置删除

//4.单链表的输出
void list_print(LL* list);

//5.单链表的销毁
void list_destroy(LL* list);

#endif

        接着开始实现链表的基本功能。

        以下是单链表的功能函数源文件 linklist.c。

//linklist.c
//单链表功能实现
#include "linklist.h"

//1.单链表的创建
LL* list_init()//链表的初始化函数
{
	//创建一个单链表结构体的动态内存
	LL* temp = (LL*)malloc(sizeof(LL));

	if (NULL == temp)
	{//如果动态内存开辟失败，指针指向了NULL
		puts("动态内存开辟失败！\n");
		return NULL;
	}

	temp->head = temp->end = NULL;//单链表头结点和尾结点指向空
	temp->length = 0;//单链表的长度初始化为0

	return temp;//返回单链表结构体的动态内存
}

//链表结点的初始化函数
Node* node_init(Type val)
{
	//创建一个单链表结点结构体的动态内存
	Node* New = (Node*)malloc(sizeof(Node));

	if (NULL == New)
	{//如果单链表结点动态内存开辟失败，New指针指向了NULL
		puts("动态内存开辟失败！\n");
		return NULL;
	}

	New->data = val;
	New->next = NULL;

	return New;//返回单链表结点结构体的动态内存
}

//2.单链表数据的结点插入
//①向单链表尾部插入数据（尾插）
void list_insert_end(LL* list, Type val)
{
	if (NULL == list)
	{//如果链表不存在，则不允许插入数据
		puts("链表不存在，数据插入失败！\n");
		return;
	}

	if (NULL == list->head)
	{//如果是创建链表的第一个结点，它既是链表的头部也是链表的尾部
		list->head = list->end = node_init(val);
		list->length++;//链表长度+1
	}
	else
	{//如果不是创建链表的第一个结点，就需要将新节点连接上链表的上一个结点
		list->end->next = node_init(val);//创建一个新结点，并连接上链表的尾部
		list->end = list->end->next;//新结点成为链表尾部
		list->length++;//链表长度+1
	}
}

//②向单链表指定位置插入数据
void list_insert(LL* list, Type val, int index)
{
	if (NULL == list)
	{//如果链表不存在，则不允许插入数据
		puts("链表不存在，数据插入失败！\n");
		return;
	}

	if (index <= 0 || index > list->length + 1)
	{//如果插入的位置小于0或者大于链表长度+1，则不允许插入数据
		puts("插入数据的位置错误，数据插入失败！\n");
		return;
	}

	if (1 == index)
	{//如果插入的位置在头结点之前
		Node* New = node_init(val);//创建一个新结点
		New->next = list->head;//新结点链接上头结点
		list->head = New;//使新结点成为新的头结点
		list->length++;
		return;
	}

	if (index == list->length + 1)
	{//如果插入结点在尾结点后一个位置
		//Node* New = node_init(val);//创建一个新结点
		//list->end->next = New;//链表的尾部链接上新的结点
		//list->end = New;//新结点成为链表的尾结点
		//list->length++;
		list_insert_end(list,val);//调用链表的尾插函数完成尾部插入
		return;
	}

	else
	{//在链表的中间插入结点
		Node *temp = list->head;
		for (int i = 1; i < index - 1; ++i)
		{//找到插入位置的前一个结点
			temp = temp->next;
		}

		Node* New = node_init(val);//创建一个新结点
		New->next = temp->next;//新结点连接上插入之后的结点（先连接后面的结点，防止先连接前面后无法再找到改位置后面的位置索引）
		temp->next = New;//插入位置之前的结点连接上新结点
		list->length++;//链表长度 + 1
	}
}

//3.单链表结点的删除，并返回删除的数据
Type list_delete_Node(LL* list, int index)
{//根据位置删除
	if (NULL == list)
	{//如果链表不存在，则不允许删除数据
		puts("链表不存在，数据删除失败！\n");
		return -1;
	}

	if (NULL == list->head)
	{//如果链表的头结点不存在，则不允许删除数据
		puts("链表头结点不存在，数据删除失败！\n");
		return -1;
	}

	if (index <= 0 || index > list->length + 1)
	{//如果插入的位置小于0或者大于链表长度+1，则不允许删除数据
		puts("删除数据的位置错误，数据删除失败！\n");
		return -1;
	}

	if (1 == index)
	{//删除头结点
		Node* temp = list->head;//记录被删除的头结点
		list->head = list->head->next;//头结点的下一个结点成为新的头部
		Type val = temp->data;//记录被删除的结点数据
		free(temp);
		list->length--;
		return val;
	}

	if (index == list->length)
	{//如果删除尾结点
		Node* temp = list->head;//创建一个临时链表
		for (int i = 1; i < index; ++i)
		{//找到被删除位置的前一个结点
			temp = temp->next;
		}
		Type val = temp->data;//记录被删除的数据
		free(list->end);//释放尾部结点
		list->end = temp;//尾部结点前的一个结点成为新的尾部
		list->length--;
		return val;
	}

	else
	{//删除中间结点
		Node* temp1 = list->head;//创建一个临时链表1
		for (int i = 1; i < index - 1; ++i)
		{//找到删除位置的前一个结点
			temp1 = temp1->next;
		}
		Node* temp2 = temp1->next;//记录被删除结点的位置
		Type val = temp2->data; //记录被删除结点的数据
		temp1->next = temp2->next;//删除位置的前一个结点跳过删除位置，指向下一个结点
		free(temp2);
		list->length--;
		return val;//返回被删除的结点数据
	}
}
//4.单链表的输出
void list_print(LL* list)
{
	if (NULL == list)
	{//如果链表不存在，则不允许输出数据
		puts("链表不存在，数据输出失败！\n");
		return;
	}

	if (NULL == list->head)
	{//如果链表的头结点不存在，则不允许输出数据
		puts("链表头结点不存在，数据输出失败！\n");
		return;
	}

	//单链表存在，正常输出
	for (Node* temp = list->head; temp != NULL; temp = temp->next)
	{
		printf(TYPE_P, temp->data);
	}
	puts("NULL");
}

//5.单链表的销毁
void list_destroy(LL* list)
{
	if (NULL == list)
	{//如果链表不存在，则不用再销毁链表
		return;
	}

	Node* currNode = list->head;//创建一个链表记录当前要释放的结点
	Node* nextNode;//创建一个链表记录下一个结点

	while (currNode != NULL)//遍历链表释放每个结点的内存
	{//当当前链表的结点不为空时，删除当前结点并记录下一个结点
		nextNode = currNode->next;//暂存下一个结点的数据
		free(currNode);//释放当前结点的数据
		currNode = nextNode;//将刚才暂存的结点值赋给当前结点
	}

	free(list);//释放链表结构体的内存
	return;
}

链表的功能测试：

        编写主函数来测试linklist功能。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

#include "linklist.h"

void linklist_test();//链表功能测试函数

int main()
{
	linklist_test();

	system("pause");
	return 0;
}

void linklist_test()//链表功能测试函数
{
	LL* LL1 = list_init();//单链表的创建

	Type values;//创建临时变量

	puts("请输入单链表的数据（以回车结束）：");

	do{
		scanf(TYPE_S, &values);//输入数据进临时变量
		list_insert_end(LL1,values);//链表尾插变量
	} while ('\n' != getchar());

	puts("单链表当前的数据为：");
	list_print(LL1);//输出链表数据
	list_destroy(LL1);//使用完成以后销毁链表
}

        运行结果：输入1 2 3 5 6 4

        链表测试成功。

听心雨啊
关注
链表基础 学习文件
11-17
适合初级学C的用来学习链表这一章,是c语言学起来更加容易上手
python的链表基础知识点
12-17
链表是一种重要的数据结构，它在Python中虽然不如数组或列表那样直接存在，但可以通过类和对象的概念来模拟实现。链表不同于数组，数组中...理解链表的基本概念和操作对于学习和使用Python或其他编程语言是非常有益的。
链表基础知识详解
Python老吕的博客
03-10 1812
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 ## 2.链表的组成 --- 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时
链表的学习
qq_54593609的博客
07-16 942
链表的学习
链表基础知识详解（非常详细简单易懂）
热门推荐
qq_61672347的博客
07-10 18万+
数据结构链表详解，创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作，非常详细
FreeRTOS学习笔记——链表
m0_64880990的博客
08-18 1056
在FreeRTOS中，使用了大量的宏定义，对代码精简有很大的帮助，链表相关带参宏定义如下示。/*************************************** 节点部分 *************************************************//* 设置节点的拥有者 */
Java链表基础
qq_46638003的博客
01-07 2303
以上是对链表的基础操作,大部分都是通过遍历链表实现.
链表基础知识
tkhhhhh的博客
08-20 1000
在遍历链表时，我们通过读取当前节点的指针域找到下一个节点，并依次向下访问，从而完成增、删、改、查等基本操作。链表是计算机科学中一种基础的数据结构，它由一组节点组成，每个节点包含数据和指向下一个节点的指针（或引用）。与数组不同，链表中的元素在内存中不必是连续存储的，这使得链表在某些操作上比数组更灵活。插入和删除操作高效：链表在任意位置插入或删除节点时，只需要调整指针，不需要移动其他节点。额外内存开销：每个节点除了存储数据外，还需要存储指针，占用额外的内存。：在哈希表中，链表常用于处理冲突（例如拉链法）。
链表基础知识总结
u012531536的专栏
05-02 17万+
链表和数组作为算法中的两个基本数据结构，在程序设计过程中经常用到。尽管两种结构都可以用来存储一系列的数据，但又各有各的特点。数组的优势，在于可以方便的遍历查找需要的数据。在查询数组指定位置（如查询数组中的第4个数据）的操作中，只需要进行1次操作即可，时间复杂度为O(1)。但是，这种时间上的便利性，是因为数组在内存中占用了连续的空间，在进行类似的查找或者遍历时，本质是指针在内存中的定向偏移。然而，当...
C语言链表超详解
k666499436的博客
05-17 12万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
链表的初步学习
RogersX的博客
02-27 181
初步学习链表，掌握了一些基础内容 头结点：没有存放有效数据，便于对于链表进行相应的操作 首节点：第一个存放有效数据的节点 尾节点 头指针：指向头节点的指针变量 尾指针：指向尾节点的指针变量 ...
链表—学习笔记
qq_40114716的博客
03-05 845
知识点： 链表： 通过指针串联在一起的线性结构，每个节点包含指针域和数据域。 链表的定义及调用方式： //定义 struct ListNode { int val; // 节点存储的元素 ListNode *next； // 指向下一个节点的指针 ListNode(int x) : val (x), next(NULL) {} // 节点的构造函数 }; //构造初始化节点 ListNode* head = new ListNode(5); 类型：单链表（每个节点指向.
关于链表基础知识的详解
07-20
链表是一种基础且重要的数据结构，它在计算机科学和编程中扮演着不可或缺的...这些文件对于理解和学习链表的实现至关重要，可以通过打开.sln文件在Visual Studio中查看和运行代码，进一步深入理解链表的操作和应用。
c语言基础-c语言编程基础之链表操作示例-反转链表.zip
03-17
在压缩包中的"**c语言基础_c语言编程基础之链表操作示例_反转链表**"文件中，你可以找到关于C语言实现链表反转的具体示例代码，这将帮助你深入理解这个概念，并能动手实践。通过分析和运行这些代码，你可以看到如何...
c语言基础-c语言编程基础之链表操作示例-环形链表.zip
03-17
链表作为一种重要的数据结构，在计算机科学中有着广泛的应用，特别是在C语言编程中。本文将深入探讨C语言中的链表操作，特别是...学习并熟练运用这些知识，能提升你的C语言编程技能，为后续的高级编程打下坚实基础。
大模型输入参数学习
AI智能，无处不在
09-25 551
top_p和top_k：用于控制生成文本的多样性和连贯性。较小的值会使生成的文本更连贯但缺乏多样性，较大的值会使生成的文本更随机和多样。：用于控制生成文本的随机性。较高的值增加随机性，较低的值增加确定性。：用于控制生成文本的长度。
Nexus学习
howwickhappy的博客
09-24 1008
Nexus 是一个开源的仓库管理器，用于管理和分发软件构建的组件。
Linux入门学习：进程概念
Lvision2的博客
09-24 1093
在课本的概念中，进程程序的一个执行实例，正在执行的程序。其内核观点：担当分配系统资源（CPU时间，内存）的实体。但这些概念太笼统，并不能让我们更加清晰的知道进程是什么，实际上，进程是内核数据结构(pcb) + 程序的代码与数据。pcb(process control block)进程控制块，进程信息被放在一个叫pcb的数据结构中，可以理解为进程属性的集合。在Linux入门学习：深刻理解计算机硬件与OS体系中，我们已经了解到。
H.264学习笔记
最新发布
zfenggo的博客
09-26 791
H.264凭借其出色的压缩效率、灵活的编码方式以及高质量的视频表现，成为了现代视频技术的核心标准之一。它不仅减少了存储需求，还提高了流媒体和实时视频传输的可行性。对于从高清到超高清视频，H.264的编码能力仍然广泛适用。H.264的帧结构设计（I帧、P帧和B帧）极大地提高了视频编码的压缩效率。I帧保存完整的图像信息，P帧通过参考之前的帧减少冗余数据，而B帧则通过双向参考提供进一步的压缩优势。这种帧间的协同工作大幅降低了带宽需求和存储成本，同时保持了视频的高质量。NALU头。
链表基础与单向链表解析
单向链表是最基础的链表形式，只有一个方向的链接。链表的开头有一个头指针，指向链表的第一个节点。节点之间的连接是通过每个节点的指针域来实现的，每个节点的指针域指向其后继节点，直到最后一个节点，其指针域为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值