数据结构——线性表②（链表）

最新推荐文章于 2024-07-12 16:27:59 发布
最新推荐文章于 2024-07-12 16:27:59 发布
阅读量235 收藏 30
点赞数 38
分类专栏： C语言学习笔记 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yjagks/article/details/134118559
版权

《数据结构——线性表①（顺序表）》一文中已经讲了线性表顺序存储–顺序表相关内容，
这篇文章一起来学习 线性表的链式存储–链表↓↓↓↓↓

一、链表的定义

线性表的链式存储称为链表，那什么是链式存储呢
在这里插入图片描述
其实理解起来就和火车差不多，一节一节的火车车厢被链条连在一起，每节车厢都是独立存在的，根据不同场景的需求，火车的车厢数可以增加或者减少，这是动态可变的；

而链表就拥有以上的这些属性，一节一节的车厢就是链表中的一个一个的节点，这些节点都是独立存在的，而指向下一个节点的指针就是连接下一节车厢的链条。
在这里插入图片描述
概念:链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

链表其实在内存中的存储并不是连续的，而是随机的，而这里线性意思是，在逻辑上，表中的所有节点都串在一起了，像一条线，可以通过节点的指针域找到其他节点。

二、链表的分类

2.1 单链表

上面介绍链表引用的图片就是一个单链表。下面这也是一个单链表
单链表的每个节点存储有两个元素，一个数据域，一个指针域。
在这里插入图片描述

  • 单链表的特点是：单链表只能从头节点开始遍历，无法直接访问中间或尾部的节点。

2.2 双链表

双链表的每个节点有三个元素，两个指针域（分别是指向前一个节点和指向下一个节点的指针），一个数据域。
在这里插入图片描述
双链表的特点是：双链表打破了单链表只能向后访问的局限性，双链表在除头尾节点之外的节点处，可以向前访问。

2.3 循环链表

  • 单向循环链表↓↓↓
    在这里插入图片描述
    链表的最后一个节点指向头节点的单向链表叫 – 单向循环链表

  • 双向循环链表↓↓↓
    在这里插入图片描述

2.4 头节点和头指针

  • 头节点：链表中的一个特殊节点，它不存储任何数据，只是作为链表的起始位置
  • 头指针：指向链表第一个元素的指针

所以，对于带头结点的链表，头指针指向的是头节点； 对于不带头节点的链表，头指针指向的是链表的第一个节点。

头节点在链表数据结构中有很多好处。

  1. 头节点可以防止链表为空时指针指向NULL，从而导致程序出错。在带头结点的链表中，当链表为空时，头结点的指针域指向头结点本身，而不是NULL。

  2. 头节点方便了单链表的特殊操作，例如在表头插入或删除节点。如果不存在头节点，当进行这些操作时，就需要考虑处理空链表的情况，这会增加代码的复杂性和出现bug的机会。

  3. 头节点统一了空表和非空表的处理方式。无论链表是否为空，头指针始终指向头结点，这使得对第一个节点的操作与对中间节点的操作保持一致，减少了代码量，并降低了出现错误的可能性。

链表的结构非常多样，以下情况组合起来就有8种 (2×2×2)链表结构:
在这里插入图片描述

三、单链表的基本操作及实现函数

3.1 单链表的类型定义

typedef int elemType;
struct SqList
{
	elemType data;
	struct SqList* next;
};
typedef struct SqList SList;

3.2 带头结点的单链表代码实例

创建和初始化：创建一个SList类型的结构体变量，数据域不存储有效数据，指针域设置为空

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>

typedef int elemType;
typedef struct SqList
{
	elemType data;
	struct SqList* next;
}SqList,*pList;
typedef struct SqList SList;

pList CreatList();//创建一个带头结点的单向链表
pList BuyNode(elemType x);//创建一个节点
void HeadAdd(pList list,elemType x);//向链表中插入数据x，头插法
void Delete(pList list,elemType x);//删除链表中的数据x
void Change(pList list, elemType x,elemType newdata);//修改数据
size_t Find(pList list, elemType x);//查找数据X，返回节点位序
void Destroy(pList list);//销毁链表
void Print(pList list);//打印链表中的数据

#include"SqList.h"

pList CreatList()
{
	pList list = (pList)malloc(sizeof(SqList));
	assert(list);
	list->data = -1;//头节点的数据域不存储数据，这里我初始化为-1
	list->next = NULL;
	return list;
}

pList BuyNode(elemType x)
{
	pList node = (pList)malloc(sizeof(SqList));
	assert(node);
	node->data = x;
	node->next = NULL;
	return node;
}

void HeadAdd(pList list, elemType x)
{
	assert(list);
	pList node = BuyNode(x);
	node->next = list->next;
	list->next = node;
}

void Print(pList list)
{
	assert(list);
	pList pcur = list->next;
	while (pcur)
	{
		printf("%d->",pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

void Delete(pList list, elemType x)
{
	assert(list);
	pList pcur = list->next;
	pList prev = list;
	while (pcur)
	{
		if (pcur->data == x)
		{
			prev->next = pcur->next;
			free(pcur);
			pcur = NULL;
			return;
		}
		prev = prev->next;
		pcur = pcur->next;
	}
	printf("Delete fail\n");
}

void Change(pList list, elemType x, elemType newdata)
{
	assert(list);
	pList pcur = list->next;
	while (pcur)
	{
		if (pcur->data == x)
		{
			pcur->data = newdata;
			return;
		}
		pcur = pcur->next;
	}
	printf("Change fail\n");
}

size_t Find(pList list, elemType x)
{
	assert(list);
	int count = 1;
	pList pcur = list->next;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return count;
		}
		pcur = pcur->next;
		count++;
	}
	printf("Find fail\n");
}

void Destroy(pList list)
{
	pList pcur = list->next;
	pList next = NULL;
	while (pcur)
	{
		next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(list);
	list = NULL;
}

四、其他链表

3.1 双链表

以下是一个简单的C语言实现双链表的示例代码：

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

// 定义链表节点结构体
struct Node {
    int data;               // 存储数据
    struct Node* prev;       // 指向前一个节点的指针
    struct Node* next;       // 指向后一个节点的指针
};

// 创建新节点
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}

// 在链表尾部插入新节点
void appendNode(struct Node** headRef, int data) {
    struct Node* newNode = createNode(data);
    if (*headRef == NULL) {
        *headRef = newNode;
        return;
    }
    struct Node* curr = *headRef;
    while (curr->next != NULL) {
        curr = curr->next;
    }
    curr->next = newNode;
    newNode->prev = curr;
}

// 在链表中删除指定节点
void deleteNode(struct Node** headRef, int data) {
    struct Node* curr = *headRef;
    struct Node* prev = NULL;
    while (curr != NULL && curr->data != data) {
        prev = curr;
        curr = curr->next;
    }
    if (curr == NULL) {
        printf("Node with data %d not found.\n", data);
        return;
    }
    if (prev == NULL) {
        *headRef = curr->next;
    } else {
        prev->next = curr->next;
    }
    if (curr->next != NULL) {
        curr->next->prev = prev;
    }
    free(curr);
}

// 打印链表中的所有节点数据
void printList(struct Node* node) {
    while (node != NULL) {
        printf("%d ", node->data);
        node = node->next;
    }
    printf("\n");
}

int main() {
    struct Node* head = NULL;  // 定义链表头指针
    appendNode(&head, 1);       // 在链表尾部插入节点1
    appendNode(&head, 2);       // 在链表尾部插入节点2
    appendNode(&head, 3);       // 在链表尾部插入节点3
    printList(head);            // 打印链表中的所有节点数据，输出应为：1 2 3 
    deleteNode(&head, 2);       // 删除节点2，输出应为：1 3 
    printList(head);            // 打印链表中的所有节点数据，输出应为：1 3 
    return 0;
}

3.2 循环链表

以下是C语言实现循环链表的示例代码：

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

// 定义链表节点结构体
struct Node {
    int data;               // 存储数据
    struct Node* next;       // 指向下一个节点的指针
};

// 创建新节点
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 在链表尾部插入新节点
void appendNode(struct Node** headRef, int data) {
    struct Node* newNode = createNode(data);
    if (*headRef == NULL) {
        *headRef = newNode;
        return;
    }
    struct Node* curr = *headRef;
    while (curr->next != NULL) {
        curr = curr->next;
    }
    curr->next = newNode;
    newNode->next = *headRef;
}

// 打印链表中的所有节点数据
void printList(struct Node* node) {
    while (node != NULL) {
        printf("%d ", node->data);
        node = node->next;
        if (node == NULL) {
            printf("\n");
        }
    }
}

int main() {
    struct Node* head = NULL;  // 定义链表头指针
    appendNode(&head, 1);       // 在链表尾部插入节点1
    appendNode(&head, 2);       // 在链表尾部插入节点2
    appendNode(&head, 3);       // 在链表尾部插入节点3
    printList(head);            // 打印链表中的所有节点数据，输出应为：1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3
    return 0;
}

3.3 静态链表

静态链表是一种使用数组来模拟链表的数据结构。它通过将数组中的每个元素拆分为两个部分，一个存储数据，一个存储指向下一个元素的索引，来实现链表的功能。

以下是一个简单的C语言实现静态链表的示例代码：

#include <stdio.h>
#define MAXSIZE 100

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

Node array[MAXSIZE];
int head = -1;
int tail = -1;

void init() {
    for (int i = 0; i < MAXSIZE; i++) {
        array[i].next = -1;
    }
}

void insert(int data) {
    Node* newNode = &array[tail];
    newNode->data = data;
    if (head == -1) {
        head = tail = 0;
    } else {
        tail = (tail + 1) % MAXSIZE;
    }
    newNode->next = head;
    head = (head + 1) % MAXSIZE;
}

int search(int data) {
    Node* curr = &array[head];
    while (curr != &array[head]) {
        if (curr->data == data) {
            return (curr - array) % MAXSIZE;
        } else {
            curr = &array[curr->next];
        }
    }
    return -1; // 数据不存在
}

void delete(int data) {
    Node* prev = &array[head];
    Node* curr = &array[head];
    while (curr != &array[head]) {
        if (curr->data == data) {
            prev->next = (curr->next + 1) % MAXSIZE;
            return;
        } else {
            prev = curr;
            curr = &array[curr->next];
        }
    }
    printf("Data not found\n"); // 数据不存在
}

五、顺序表和链表的比较

顺序表和链表是两种不同的线性数据结构，它们各有优缺点，适用于不同的应用场景。

他们在以下几个方面有较大的区别

  1. 内存空间：顺序表在内存中占据连续的空间，而链表则可以非连续。这使得顺序表在空间利用率上较优，因为它不需要为每个节点额外分配存储空间来存储指针。
  2. 插入和删除操作：在顺序表中，插入和删除操作需要移动元素来保持连续性，因此时间复杂度通常为O(n)。然而，在链表中，插入和删除操作仅需要更改指针，因此时间复杂度为O(1)。链表在插入和删除操作上更高效。
  3. 查找操作：在顺序表中，查找操作的时间复杂度通常为O(1)，因为我们可以直接通过索引访问元素。而在链表中，查找操作需要从头部开始遍历，时间复杂度为O(n)。
  4. 动态增长：顺序表通常只能在固定大小的内存空间中操作，而链表可以通过动态分配内存来增长。这意味着链表可以更灵活地处理更多的数据。
  5. 适用场景：顺序表更适合于小规模数据，因为它在内存中占据连续空间，可以快速访问元素。而链表更适合于大规模数据，因为它可以动态增长并且插入和删除操作更高效。

其实顺序表和链表各有优缺点，选择使用哪种数据结构取决于具体的应用场景和需求。

weil_li
关注
  • 38
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 47
    评论
专栏目录
数据结构——线性表的比较
qq_65134001的博客
01-26 181
线性表的比较
数据结构——线性表
02-06
另外还实现了简单单链表、简单顺序线性表、从A链表中删除B和C链表共有的元素、单链表逆置（以整数为例）、将链表中元素按递增排序并删除所选定范围内的元素、求一个新的集合A为A和B的交集（采用单链表作为存储结构）...
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
初阶数据结构——线性表——链表——不带头单向链表
dtxew love c++
10-20 2843
????????想快速入门数据结构，推荐订阅作者的初阶数据结构专栏！此专栏预计更新：顺序表，链表，栈，队列，二叉树，排序算法等等 ????????初阶数据结构我们通过c语言实现，所以此专栏也可以帮助大家巩固大家的c语言知识 知识回顾 在前一章中我们已经介绍了顺序表，相信大家对顺序表的实现已经有所了解了吧！ 但是，这种数据结构，难免会有以下的缺陷 我们在中间位置插入或删除数据的话，可能需要挪动后面的所有数据，时间复杂度较高==(O(n))== 我们的空间是按照2倍的常数开辟的，可能会造成空间的浪费，比
数据结构 基本代码——线性表，链表实现 C语言
LloveN0128的博客
10-30 440
单链表功能的实现。
数据结构——线性表：链表
weixin_56781779的博客
10-09 156
链表是真正的动态数据结构
【数据结构——线性表之链表】
lflcodeplus的博客
10-04 2276
线性表之《链表的表示及基本操作的实现》 目录线性表之《链表的表示及基本操作的实现》一、单链表（一）单链表的描述（一）单链表的操作实现1、初始化2、查找3、插入4、删除二、循环链表三、循环链表 一、单链表 （一）单链表的描述 typedef struct LNode { ElemType data;//结点数据域 struct LNode* next;//结点指针域 }LNode ,*LinkList; 变量定义： LNode* p, * q LinkList L; p, q, L都是指针变量，
数据结构——线性表知识思维导图
＃两个西柚
07-30 2914
此博客主要是线性表部分的知识思维导图 便于对线性表这一章节的知识在脑中形成一个知识体系 具体重要代码实现可以点击 ???? 传送门 一、线性表的定义和基本操作 二、顺序表的定义 三、顺序表的插入删除 四、顺序表的查找 五、单链表的定义 六、单链表的插入与删除 七、单链表的查找与建立 八、双链表 ...
初阶数据结构——线性表——链表——带头双向循环链表
dtxew love c++
10-28 2680
????????想快速入门数据结构，推荐订阅作者的初阶数据结构专栏！此专栏预计更新：顺序表，链表，栈，队列，二叉树，排序算法等等 ????????初阶数据结构我们通过c语言实现，所以此专栏也可以帮助大家巩固大家的c语言知识 ????????源代码已上传至我的码云 ????????博主的微信公众号关注啦，关注我每天学习一道题，点我关注 前言 其中在链表的实现中有很多种实现方法，主要取决于以下几个因素 单向还是双向？ 循环还是不循环？ 带头还是不带头 这几个特征两两组合，就可以看做一种链表的
52.【Java 数据结构——线性表】
qq_69683957的博客
09-09 3247
增删改查
数据结构——线性表的实现.zip
09-18
本资料包“数据结构——线性表的实现.zip”着重介绍了线性表的两种常见实现方式：链表和数组。 1. 链表实现： 链表是一种物理存储单元非连续、非顺序的存储结构，它通过节点间的指针链接来表示元素之间的逻辑关系...
数据结构——线性表分享.pdf
01-01
数据结构——线性表分享 一、顺序存储结构 在数据结构中，顺序存储结构是一种常用的存储方式，它将线性表的每个元素存储在一块连续的存储空间中。这种存储方式的优点是可以快速访问任意一个元素，但缺点是插入或...
数据结构实验——线性表子系统
07-31
线性表是数据结构中最基础且重要的概念之一，它是由n(n≥0)个相同类型元素组成的有限序列。在这个实验中，我们主要关注线性表的链式存储结构，特别是字符型的单链表。实验的目标是理解线性表的特点，掌握顺序存储和...
数据结构——线性表(选择题).docx
07-11
线性表是数据结构中的一种基础类型，它是由n（n>=0）个相同类型元素构成的有限序列。在这个序列中，每个元素都有一个直接前驱（除了第一个元素）和一个直接后继（除了最后一个元素），并且这个序列可以为空。线性表...
数据结构【顺序表】
qq_67578580的博客
07-12 961
我们需要创建一个seqlist.h头文件，seqlist.c文件存放函数，还有一个.c的测试文件。
数据结构 Java DS——链表部分经典题目 (1)
cjejwe的博客
07-09 653
笔者计划在暑假啃完JavaDS,Mysql的内容当然也会继续更这次给读者们分享的是链表的几个比较典型的题目,关于如何手搓一个链表,笔者还在筹划中,毕竟链表的种类也有那么多,但是在下面的题目中,只有单向链表。
数据结构之单链表在不带标准头的情况下C，C#，C++分别怎么实现？
qq_35320456的博客
07-12 279
数据结构是计算机科学中非常重要的一部分，它帮助我们理解和操作数据。单链表是数据结构中的一种基本类型，它由一系列节点组成，每个节点包含数据域和指向列表中下一个节点的指针。在本文中，我们将详细讨论单链表的概念、操作和如何在几种常见的编程语言中实现它。
数据结构第23节 线性搜索
最新发布
hummhumm的专栏
07-12 212
线性搜索（Linear Search），也称为顺序搜索，是最基本的搜索算法之一。它的工作原理是通过遍历数组或列表中的每一个元素，直到找到目标值为止，或者遍历完所有元素后确定目标值不存在于列表中。线性搜索的时间复杂度为O(n)，其中n是列表中元素的数量。这是因为最坏情况下，你可能需要检查列表中的每一个元素才能找到目标值或确定它不在列表中。
软考辅导-数据结构与算法(“结点”文档)共134张.pptx
12-01
包含134张PPT，涵盖了数据结构的基础概念、逻辑结构、存储结构以及各类算法的分析和应用，如线性表、树、图、排序算法和查找算法等。" 在数据结构与算法的学习中，首先我们要理解数据结构这一核心概念。数据结构是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 47
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值