【数据结构】链表基本操作（增、删、查、改）

最新推荐文章于 2022-11-12 21:13:23 发布
最新推荐文章于 2022-11-12 21:13:23 发布
阅读量382 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/waves_K/article/details/95757362
版权
本文介绍了链表的概念，以及链表的分类，重点讨论了无头单向不循环链表和带头双向循环链表的基本操作实现。链表作为一种非连续、非顺序的存储结构，其逻辑顺序依赖于指针链接。文章中详细阐述了这两种链表的特性和应用场景，并探讨了它们在实际操作中的实现方法。
摘要由CSDN通过智能技术生成

1. 概念

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

2. 链表的分类

  根据链表是否是单向的、是否带头结点、是否循环可以将量表分为 8 种不同的结构。但是这里我们只研究最简单的 不带头结点的单向不循环链表，以及最难的带头结点的双向循环链表。
  1. 不带头的单向不循环链表，结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试的重点和常考点。
  2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。

3. 无头单向不循环链表基本操作的实现

SList.h

#pragma once

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

typedef int SListDataType;

// 链表中的一个节点
typedef struct Node{
    SListDataType value;    // 值
    struct Node *next;      // 下一个节点的地址
} Node;

// Single List 
typedef struct SList{
    Node *first;    // *head; 第一个节点的地址
} SList;

// 初始化 / 销毁
void SListInit(SList *slist);

void SListDestory(SList *slist);
// 增 / 删 / 查 / 改
// 头插
void SListPushFront(SList *slist, SListDataType data);

// 尾插
void SListPushBack(SList *slist, SListDataType data);

// 头删
void SListPopFront(SList *slist);

// 尾删
void SListPopBack(SList *slist);

// 查找，只能遍历查找  时间复杂度O(n)
Node *SListFind(SList *slist, SListDataType data);

// 在 pos 结点的后面插入一个节点
void SListInsertAfter(SList *slist, Node *pos, SListDataType data);

// 在 pos 结点的后面删除一个节点
void SListEraseAfter(SList *slist, Node *pos);

// 删除第一个结点值为 data 的结点
void SListRemove(SList *slist, SListDataType data);

// 删除所有值为 data 的结点
void SListRemoveAll(SList *slist, SListDataType data);

//
// 测试专用打印函数
//
void SListPrint(SList *slist);

SList.c

#include"SList.h"

// 单链表初始化
void SListInit(SList *slist){
    slist->first = NULL;
}

// 单链表头插
// 注意问题：
//    1.链表为空  first --> NULL
//    2.链表不为空  first -- > 1 -- > 2 --> 3 --> 4 --> NULL
//经过思考，链表为空和不为空的情形是一样的，所以不需要做特殊处理
void SListPushFront(SList *slist, SListDataType data){
    // 1.创建新结点,就是给结点开辟新空间
    Node *node = (Node*)malloc(sizeof(Node));
    node->value = data;

    // 2.更改链表的关系
    node->next = slist->first;
    slist->first = node;
}

// 尾插
void SListPushBack(SList *slist, SListDataType data){
    // 1.创建新结点
    Node *node = (Node*)malloc(sizeof(Node));
    node->value = data;
    node->next = NULL;

   // 2.遍历链表，找到最后一个元素
    if(slist->first == NULL){
        slist->first = node;
    }
    else{
        // 找原来链表的最后一个结点
        Node *current = slist->first;
        while(current->next != NULL){
            current = current->next;
        }

        // 循环结束，此时 current->next 一定是 NULL,也就是链表最后一个节点
        current->next = node;
    }
}


// 头删
void SListPopFront(SList *slist){
    // 1.链表中没有节点
    assert(slist->first != NULL);

    // 2.链表中有结点
    // 由于是头删，如果直接删除链表第一个结点
    // 就会导致链表的头指针找不到链表的第二个结点
    // 为了避免这种情况，先定义一个指针，用来存放链表第二个节点的位置
    Node *second = slist->first->next;
    free(slist->first);
    slist->first = second;
}

// 尾删
void SListPopBack(SList *slist){
    // 排除链表中没有结点的情况
    assert(slist->first != NULL);

    // 只有一个节点的情况
    if(slist->first->next == NULL){
        free(slist->first);
        slist->first = NULL;
        return;
    }

    // 有两个即两个结点以上的情况
    // 找到倒数第二个结点，做记录
    Node *current;
    for(current = slist->first; current->next->next != NULL; current = current->next);
    free(current->next);
    current->next = NULL;
}

// 查找
Node *SListFind(SList *slist, SListDataType data){
    for(Node *current = slist->first; current != NULL; current = current->next){
        if(current->value == data){
            return current;
        }
    }
    return NULL;
}

// 在 pos 结点的后面插入一个结点
void SListInsertAfter(SList *slist, Node *pos, SListDataType data){
    (void)slist;
    // 1.创建新结点
    Node *node = (Node*)malloc(sizeof(Node));
    node->value = data;
    node->next = pos->next;
    pos->next = node;
}

// 在 pos 结点的后面删除一个结点
void SListEraseAfter(SList *slist, Node *pos){
    // 这句代码是为了消除 slist 变量未被使用的警告
    (void)slist;
    // 定义一个指针，保留 pos 结点之后的第二个结点的地址
    Node *next = pos->next->next;
    free(pos->next);
    pos->next = next;
}

// 删除第一个结点值为 data 的结点
void SListRemove(SList *slist, SListDataType data){
    // 1.先确认第一个节点的值是不是 data 
    // 如果是：头删
    // 如果不是：继续
    // 2.拿一个指针遍历链表的结点，判断指针指向结点的下一个结点保存的值是不是 data
    // 指针符号：current 
    // 指针范围[first, 倒数第二个结点]
    // 3.如果找到了，进行删除
    // current = current->next->next;
    // 释放原来的结点 current->next;
    

    // 第一种情况:链表中一个结点也没有
    if(slist->first == NULL){
        return;
    }

    // 第二种情况：链表中有结点
    // 判断链表中的第一个结点的值是不是 data
    // 链表中的一个结点的值是 data
    if(slist->first->value == data){
        // 记录链表的第二个节点
        Node *second = slist->first->next;
        // 释放第一个结点
        free(slist->first);
        slist->first = second;
    }
    // 链表中的第一个结点的值不是 data
    else{
        // 遍历链表，查找链表中结点的值为 data 的结点
        Node* current = slist->first;
        while(current != NULL){
            if(current->next->value == data){
                Node* next = current->next;
                current->next = current->next->next;
                free(next);
                return;
            }
            current = current->next;
        }
    }
}


// 删除所有值为 data 的结点
void SListRemoveAll(SList *slist, SListDataType data){
    if(slist->first == NULL){
        return;
    }
    Node* current = slist->first;
    while(current->next != NULL){
        if(current->next->value == data){
            Node* next = current->next;
            current->next = current->next->next;
            free(next);
        }
        else{
            current = current->next;
        }
    }
    // 除了第一个结点没有检查，其他的结点都已经检查并删除了
    if(slist->first->value == data){
        // 头删
        Node* first = slist->first;
        slist->first = slist->first->next;
        free(first);
    }
}

// 销毁
void SListDestory(SList *slist){
    while(slist->first != NULL){
    SListPopBack(slist);
    }
}

/
// 这是一个测试专用的打印函数
/

void SListPrint(SList *slist){
    assert(slist);

    Node* current = slist->first;
    while(current != NULL){
        printf("%d ",current->value);
        current = current->next;
    }
    printf("\n");
}

main.c

#include"SList.h"

int main(){
    SList sl;
    SListInit(&sl);
    SListPushFront(&sl, 1);
    SListPushFront(&sl, 2);
    SListPushFront(&sl, 3);
    SListPushFront(&sl, 4);
    SListPushFront(&sl, 5);
    SListPrint(&sl);

    //SListPushBack(&sl, 1);
    //SListPushBack(&sl, 2);
    //SListPushBack(&sl, 3);
    //SListPushBack(&sl, 4);
    //SListPrint(&sl);

    //SListPopFront(&sl);
    //SListPopFront(&sl);
    //SListPopFront(&sl);
    //SListPrint(&sl);

    //SListPopBack(&sl);
    //SListPopBack(&sl);
    //SListPrint(&sl);

    //Node *SListFind(&sl, 2);
    //
    //SListPushFront(&sl, 3);
    //SListPushFront(&sl, 4);
    //SListPushFront(&sl, 5);
    //SListPushFront(&sl, 6);
    //SListPrint(&s);

    //SListInsertAfter(&sl, 3, 7);
    //SListPrint(&sl);

    //SListEraseAfter(&sl, 3);
    //SListPrint(&sl);

    //SListPushBack(&sl, 5);
    //SListPrint(&sl);

    //SListRemove(&sl, 5);
    //SListPrint(&sl);

    //SListRemoveAll(&sl, 1);
    //SListPrint(&sl);
    //system("pause");
    //return 0;
}
  • 4. 带头双向循环链表基本操作的实现

4. 带头双向循环链表基本操作的实现

waves_K
关注
专栏目录
线性表的基本操作（一）
qq_31265361的博客
10-15 613
线性表的基本操作线性表的定义 线性表是具有相同特性数据元素的一个有限序列。该序列中所含元素的个数叫做线性表的长度（n）。注意：n可以等于0，表示线性表是一个空表。空表也可以作为线性表。线性表可分为顺序表和链表，本篇文章中以顺序表为主。 1.顺序表的结构定义#define maxSize 100 typedef struct{ int data[maxSize];//存放顺序表元素的数组
【数据结构】线性表—顺序表与链表的基本操作（增删改查）
m0_63425312的博客
04-18 1397
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？1.引入库二、使用步骤1.引入库2.读入数据总结 前言 线性表的存储结构分为顺序存储和链式存储，顺序存储需要一组地址连续的存储单元依次存储线性表的数据结构，而链式存储结构使用一组任意的存储单元存储线性表的数据元素。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 1.引入库 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import p.
线性表的基本算法（插入、删除、建立、查找）
06-29
顺序表、链表的基本算法插入、删除、建立、查找
数据结构-线性表（顺式实现 增 删 改 查）
Ray的博客
11-01 593
线性表的基本操作 顺序存储实现 #define N 100 //线性表的最大长度 typedef int data_t typedef struct{ data_t data[N]; //表的存储空间 int last; //当前表尾指针 }sqlist_t,*sqlink_t; //顺序表类型 顺序表操作-创建 sqlink_t L; L = (seqlist_t *)malloc(sizeof(seqlist_t)); L->last=-1; 例： //seqlist.h #i
线性表的实现程序（结构体、初始化、增加、删除、查找输入的元素值）
06-03
线性表的实现程序（结构体、初始化、增加、删除、查找输入的元素值）
线性表 -- 增、查、改、删操作
绿色羽毛
10-01 1572
线性表： 具有相同数据类型的n个数据元素的有限序列，该序列所含个数叫做线性表的长度，用n (n≥0)表示； 注意：n可以等于0 ，表示线性表为空表；线性表可以是有序的，也可以是无序的。 逻辑特性： 只有1个表头元素、表头元素没有前驱，表尾元素没有后继，除表头和表尾元素之外，其它元素只有1个直接前驱，也只有一个直接后继。 1、顺序表 顺序表就是把线性表中的所有元素按照其逻辑顺序依次存储到从指定的存...
Java描述数据结构学习之链表的增删改查详解
08-27
本文将从链表的基本概念、链表的定义、链表的增删改查操作等方面对Java描述数据结构学习之链表的增删改查进行详细的解释。 链表是一种常见的基础数据结构，它是一种线性表，但在内存中它并不是顺序存储的，而是以...
C语言数据结构库（队列，栈，链表，树的增删改查）
07-09
本资料包提供了一套完整的C语言数据结构库，特别关注于队列、栈、链表和树这四种基本数据结构的增删改查操作。 1. 队列：队列是一种先进先出（FIFO）的数据结构，类似于现实生活中的排队。在这个库中，你可以找到...
用c语言实现链表增删改查
11-07
根据提供的文件信息，本文将详细解释如何使用C语言来实现链表的基本操作——增加、删除、修改和查询。这些操作是数据结构学习中的基础部分，对于理解更复杂的数据结构非常有帮助。 ### 一、链表简介 链表是一种...
C语言之航空信息查询系统-使用双向循环链表实现系统的增删改查操作
最新发布
09-20
双向循环链表是一种特殊的链式存储结构，它允许我们在链表的两个方向上进行遍历，这对于执行增删改查操作非常有用。下面我们将详细探讨这个系统的设计与实现。 首先，我们要理解双向循环链表的基本概念。双向循环...
线性表中顺序表的增删改查
06-21
顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查顺序表 增删改查
单链表c语言实现增删改查操作
09-21
VS2008运行环境 c语言实现单链表增删改查操作 并输出到控制台上
数据结构--链表的增删改查
Z_JUAN1的博客
06-20 472
#pragma once #include&lt;stdio.h&gt; #include&lt;assert.h&gt; #include&lt;stdlib.h&gt; typedef int DataType; typedef struct SListNode{ DataType data; struct SListNode *pNext; } SListNode; //初始...
（数据结构）单链表 增、删 、查 、改 ，本人写的有问题欢迎交流 ，指正错误
weixin_45413401的博客
09-04 557
#include <stdio.h> #include <stdlib.h> //结构体 struct node { int data ; //数据域 struct node *next; //指针域 }; //尾插 int add_node(struct node *head ,int data) { struct node *new = malloc(sizeof(struct node)); //初始化节点 new->next = NULL ; new->data
线性表的顺序表——增、删、查、改、排序
zhourong0511的博客
03-01 700
顺序表——用一段地址连续的存储单元一次存储数据元素的线性结构。 SeqLIst.h #pragma once #include&amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; #include&amp;amp;amp;lt;windows.h&amp;amp;amp;gt; #include&amp;amp;amp;lt;assert.h&amp;amp;amp;gt; #define MAX_SIZE 4 ty
实现对顺序表的增、删、改、查等操作
Dr_Cassie的博客
03-01 1005
顺序表在计算机内存中以数组的形式保存的线性表，线性表分为顺序存储和链式存储。 顺序存储：逻辑上是连续的，在内存上也是连续的。 链式存储：逻辑上连续，内存上不一定连续。 顺序表又分为定长顺序表（不可扩容的），和不定长顺序表（可扩容，用realloc动态开辟数组）。 以下为定长顺序表的基本操作： （1）定义顺序表 # define ELEM_SIZE 5 typedef int ELEM...
数据结构入门——链表（SeqList）详解（初始化、增、删、查、改）
ZHA_123的博客
11-12 1733
概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。由图可以看出链表的结构在逻辑上是连续的，但是在内存中不一定连续。链表的结点是在堆上开辟的。在堆上开辟的两段空间，可能连续，也可能不连续。之后的一篇博客会讲一下关于链表的OJ题。
数据结构与算法之线性表简单定义（链式结构存储查，增，删）
maoye的博客
09-21 478
前篇说到了线性表顺序存储结构。这篇说下线性表链式存储结构！ 链表就是前一个元素里面有一个指针指向下一个元素的地址。以此类推。链条型的数据结构 这样就有了头指针和头结点，而他们有和异同了   头指针： --头指针是指链表指向第一个结点的指针，若链表有头结点，则是指向头结点的指针 --头指针具有标识作用，所以常用头指针冠以链表的名字（指针变量的名字） --无论链表是否为空，头指针均不为空...
数据结构与算法之线性表简单定义（顺序结构存储查，增，删）
maoye的博客
09-20 311
线性表（List） 由零个或多个数据元素组成的有限序列，它是一个序列，也就是说元素之间是有个先来后到的，若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他元素有且只有一个前驱和后继，另外，线性表强调是有限的，事实上无论计算机发展多强大，它处理的元素都是有限的。 用数学语言来： 线性表记为（a1,a2,.......,ai-1,ai,ai+1,......,an） 则ai-1是ai...
C语言实现链表操作：增删改查
"这篇资源是关于使用C语言实现链表数据结构的基本操作，包括增加、删除、修改和查询。作者通过定义一个结构体`Student`来存储学生信息，如姓名(name)、学号(sno)和成绩(score)，并用指针实现链表的动态扩展。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值