链表的增、删、查、找

最新推荐文章于 2024-04-18 16:22:38 发布
最新推荐文章于 2024-04-18 16:22:38 发布
阅读量271 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 结构 数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangye3017/article/details/78857590
版权

基本结构

typedef int DataType;

typedef struct SListNode
{
struct SListNode* _next;
DataType _data;
}SListNode;

链表结构分为两部分，一部分是数据域，存放的是节点的数据部分，另一部分是指针域，保存下一节点的地址

新建节点

和动态顺序表不一样，每次只开辟一个节点的空间，将其节点的指针域赋为空

代码：

SListNode* BuySListNode(DataType x)
{
    SListNode *NewNode =(SListNode *) malloc(sizeof(SListNode));
    if (NewNode==NULL)
    {
        perror("申请失败");
        exit(EXIT_FAILURE);

    }
    NewNode->_data = x;
    NewNode->_next = NULL;


    return NewNode;
}

打印链表

动态顺序表是通过下标来进行访问，而链表是通过指针访问到每一个节点，当某一节点的指针域为空时，说明链表到尾

代码：

void SListPrint(SListNode* pHead)
{


    while (pHead != NULL)
    {
        printf("%d  ", pHead->_data);
        pHead = pHead->_next;
    }
    printf("\n");
}

链表的头插（过程如下图）

这里写图片描述

代码：



void SListPushFront(SListNode** ppHead, DataType x)
{

    if ((*ppHead) == NULL)
    {
        SListNode *cur = BuySListNode(x);
        *ppHead = cur;
    }
    else
    {
        SListNode *cur = BuySListNode(x);
        cur->_next = *ppHead;
        *ppHead = cur;


     }

}

链表头删（过程如下图）

这里写图片描述

代码：

void SListPopFront(SListNode** ppHead)
{
    if (*ppHead == NULL)
    {
        printf("list is empty\n");
    }

    else
    {
        SListNode *cur = *ppHead;
        free(cur);
        *ppHead = (*ppHead)->_next;

    }

}

尾插（过程与头插想类似在这里不在画图）

代码：

void SListPushBack(SListNode** ppHead, DataType x)
{
    assert(ppHead);
    SListNode *cur = *ppHead;
    if (*ppHead == NULL)
    {
        *ppHead = BuySListNode(x);
    }
    else
    {
        while (cur->_next != NULL)
        {
            cur = cur->_next;
        }

        cur->_next = BuySListNode(x);

    }


}

尾删

代码：

void SListPopBack(SListNode** ppHead)
{

    SListNode *cur = *ppHead;
    if (*ppHead == NULL)
    {
        printf("List is empty\n");
    }
    else if ((*ppHead)->_next == NULL)
    {
        free(*ppHead);
        *ppHead = NULL;
    }
    else
    {
        while (cur->_next->_next != NULL)
        {
            cur = cur->_next;
        }

        free(cur->_next);
        cur->_next = NULL;
    }

}

任意位置插入（指头插）

在这里需要注意几点：
1）链表为空时，只需调用头插即可
2）链表有一个及以上节点时，需注意保存该位置的前一位置，将其与前一位置相连

这里写图片描述

代码：

void SListInsest(SListNode** ppHead, SListNode* pos, DataType x)
{
    assert(*ppHead);

    SListNode* prev = *ppHead;//记录pos位置的前一个节点
    SListNode* cur = *ppHead;//头结点

    if (pos == cur)
    {
        SListPushFront(ppHead, x);
    }
    else
    {
        while (prev->_next != pos)
        {
            prev = prev->_next;
        }
        SListNode* NewNode = BuySListNode(x);
        NewNode->_next = prev->_next;
        prev->_next = NewNode;
    }   
}

任意位置删除（删除方法类似头插，不在画图）

代码：

void SListErase(SListNode** ppHead, SListNode* pos)
{

    if (*ppHead == NULL)
    {
        printf("list is empty\n");
    }
    else 
    {
        if (pos == *ppHead)
        {

            SListNode *cur = *ppHead;
            (*ppHead) = (*ppHead)->_next;
            free(cur);
        }
        else if (pos == NULL)
        {
            SListPopBack(&pos);
        }
        else
        {
            SListNode* prev = *ppHead;
            while (prev->_next != pos)
            {
                prev = prev->_next;
            }

            prev->_next = pos->_next;
            free(pos);
        }

    }




}

下面给出完整代码及测试用例：

SeqList.c:

  SListNode* list;


//新建一个节点
SListNode* BuySListNode(DataType x)
{
    SListNode *NewNode =(SListNode *) malloc(sizeof(SListNode));
    if (NewNode==NULL)
    {
        perror("申请失败");
        exit(EXIT_FAILURE);

    }
    NewNode->_data = x;
    NewNode->_next = NULL;


    return NewNode;
}



//打印链表
void SListPrint(SListNode* pHead)
{


    while (pHead != NULL)
    {
        printf("%d  ", pHead->_data);
        pHead = pHead->_next;
    }
    printf("\n");
}

//释放节点
void SListDestory(SListNode** ppHead)
{
    assert(ppHead);
    free(*ppHead);
    *ppHead = NULL;

}


//尾插
void SListPushBack(SListNode** ppHead, DataType x)
{
    assert(ppHead);
    SListNode *cur = *ppHead;
    if (*ppHead == NULL)
    {
        *ppHead = BuySListNode(x);
        (*ppHead)->_next = NULL;
    }
    else
    {
        while (cur->_next != NULL)
        {
            cur = cur->_next;
        }

        cur->_next = BuySListNode(x);

    }


}


//尾删
void SListPopBack(SListNode** ppHead)
{

    SListNode *cur = *ppHead;
    if (*ppHead == NULL)
    {
        printf("List is empty\n");
    }
    else if ((*ppHead)->_next == NULL)
    {
        free(*ppHead);
        *ppHead = NULL;
    }
    else
    {
        while (cur->_next->_next != NULL)
        {
            cur = cur->_next;
        }
        free(cur->_next);
        cur->_next = NULL;
    }

}


//头插
void SListPushFront(SListNode** ppHead, DataType x)
{

    if ((*ppHead) == NULL)
    {
        SListNode *cur = BuySListNode(x);
        *ppHead = cur;
    }
    else
    {
        SListNode *cur = BuySListNode(x);
        cur->_next = *ppHead;
        *ppHead = cur;

    }

}

//头删
void SListPopFront(SListNode** ppHead)
{
    if (*ppHead == NULL)
    {
        printf("list is empty\n");
    }

    else
    {
        SListNode *cur = *ppHead;
        *ppHead = (*ppHead)->_next;
        free(cur);

    }

}


//任意位置插入
void SListInsest(SListNode** ppHead, SListNode* pos, DataType x)
{
    assert(ppHead);
    //assert(pos);
    SListNode* prev = *ppHead;//记录pos位置的前一个节点
    SListNode* cur = *ppHead;//头结点

    if (pos == cur)
    {
        SListPushFront(ppHead, x);
    }
    else
    {
        while (prev->_next != pos)
        {
            prev = prev->_next;
        }
        SListNode* NewNode = BuySListNode(x);
        NewNode->_next = prev->_next;
        prev->_next = NewNode;
    }   
}


//查找
SListNode* SListFind(SListNode* pHead, DataType x)
{
    assert(pHead);
    SListNode *cur = pHead;
    while (cur != NULL)
    {
        if (cur->_data == x)
        {
            return  cur;
        }
        cur = cur->_next;
    }
    return NULL;

}

//任意位置删除
void SListErase(SListNode** ppHead, SListNode* pos)
{

    if (*ppHead == NULL)
    {
        printf("list is empty\n");
    }
    else 
    {
        if (pos == *ppHead)
        {

            SListNode *cur = *ppHead;
            (*ppHead) = (*ppHead)->_next;
            free(cur);
        }
        else if (pos == NULL)
        {
            SListPopBack(&pos);
        }
        else
        {
            SListNode* prev = *ppHead;
            while (prev->_next != pos)
            {
                prev = prev->_next;
            }

            prev->_next = pos->_next;
            free(pos);
        }

    }




}

test.c

//测试尾插
void TestSListPushBack()
{

    list = NULL;
    SListPushBack(&list, 0);
    SListPushBack(&list, 1);
    SListPushBack(&list, 2);
    SListPushBack(&list, 3);
    SListPushBack(&list, 4);
    SListPushBack(&list, 5);
    SListPrint(list);

}



//测试尾删
void TestSListPopBack(SListNode** ppHead)
{
    list = NULL;
    SListPushBack(&list, 0);
    SListPushBack(&list, 1);
    SListPushBack(&list, 2);
    SListPushBack(&list, 3);
    SListPushBack(&list, 4);
    SListPushBack(&list, 5);
    SListPrint(list);


    SListPopBack(&list);
    SListPopBack(&list);
    SListPopBack(&list);
    SListPopBack(&list);
    SListPopBack(&list);
    SListPopBack(&list);

    SListPrint(list);

}

//测试头插
void TestSListPushFront()
{
    list = NULL;
    SListPushFront(&list, 0);
    SListPushFront(&list, 1);
    SListPushFront(&list, 2);
    SListPushFront(&list, 3);
    SListPushFront(&list, 4);
    SListPrint(list);



}

//测试头删
void TestSListPopFront()
{
    list = NULL;
    SListPushFront(&list, 0);
    SListPushFront(&list, 1);
    SListPushFront(&list, 2);
    SListPushFront(&list, 3);
    SListPushFront(&list, 4);
    SListPrint(list);

    SListPopFront(&list);
    SListPopFront(&list);
    SListPopFront(&list);
    SListPopFront(&list);
    SListPopFront(&list);

    SListPrint(list);



}



//测试查找
void  TestSListFind()
{

    list = NULL;
    SListPushFront(&list, 0);
    SListPushFront(&list, 1);
    SListPushFront(&list, 2);
    SListPushFront(&list, 3);
    SListPushFront(&list, 4);





    SListNode* cur = SListFind(list, 3);
    printf("%d\n", cur->_data);

}

//测试任意位置插入
void TestSListInsest()
{


    list = NULL;
    SListPushFront(&list, 0);
    SListPushFront(&list, 1);
    SListPushFront(&list, 2);
    SListPushFront(&list, 3);
    SListPushFront(&list, 4);
    SListPrint(list);


    SListNode *ret = SListFind(list, 0);
    SListInsest(&list, ret, 78);
    ret = SListFind(list, 4);
    SListInsest(&list, ret, 78);
    ret = SListFind(list, 2);
    SListInsest(&list, ret, 78);

    SListPrint(list);

}

//测试任意位置删除
void TestSListErase(SListNode** ppHead, SListNode* pos)
{
    list = NULL;
    SListPushFront(&list, 0);
    SListPushFront(&list, 1);
    SListPushFront(&list, 2);
    SListPushFront(&list, 3);
    SListPushFront(&list, 4);
    SListPrint(list);


    SListNode *ret = SListFind(list, 4);
    SListInsest(&list, ret, 23);
    SListPrint(list);




    ret = SListFind(list, 4);
    SListErase(&list, ret);
    ret = SListFind(list, 23);
    SListErase(&list, ret);
    ret = SListFind(list, 0);
    SListErase(&list, ret);
    SListPrint(list);

}
so_u
关注
专栏目录
链表简单实现（增删查改）
三毛创作记
12-26 2805
关于链表的原理已经有一篇链表文章写的很详细了，这篇文章主要侧重于代码的实现，主要使用go实现。
c++实现链表增删改查
07-17
c++实现链表增删改查
链表的增删
迁就100
04-20 276
链表一般使用的是不带头单向非循环链表，在Java的集合框架库中 LinkedList 底层实现是不带头双向循环链表。链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 public class Link { //链表中的第一个结点 public static class Node { //下个结点的索引 ...
单链表（增删）
qq_44404616的博客
11-03 162
主代码 1、定义单链表类 public class MySignal2 { private ListNode2 head; MySignal2() { this.head = null; } public ListNode2 getHead() { return head; } public void setHe...
链表的增删查改
m0_48711099的博客
01-28 121
#include <stdio.h> #include<stdlib.h> typedef struct student { int num; float score; struct student* pnext; }stu, * pstu; void list_head_insert(pstu* pphead, stu** pptail, int i) { //头插法 pstu pnew = (pstu)mal
用c语言实现链表增删改查
11-07
根据提供的文件信息，本文将详细解释如何使用C语言来实现链表的基本操作——增加、删除、修改和查询。这些操作是数据结构学习中的基础部分，对于理解更复杂的数据结构非常有帮助。 ### 一、链表简介 链表是一种...
C/C++链表增删改查排序操作
11-21
使用C++实现双向循环链表的增删改查排序等操作，可查看个人博客的【[数据结构和算法]C/C++双向循环链表实现(增删改查排序)】--链接https://blog.csdn.net/slimmm/article/details/84317806
Java单链表增删改查的实现
08-15
下面我们将详细探讨如何在Java中实现单链表的增、删、改、查功能，以及如何进行选择排序、冒泡排序和反转排序。 1. **单链表的定义**： - 单链表的每个节点通常包括两部分：数据域（存储元素）和指针域（存储下一...
java实现链表增删改查
01-07
用java实现链表增删改查
c语言 单链表的增删改查
04-25
C语言编写的单链表增删改查，实现了单链表的增加，删除，修改，查询等功能
数据结构之链表增删查改（最详细注释和最清晰思路，附完整代码）
include520的博客
07-23 3130
本文通过结构体指针实现链表的增删查改，适合新手入门
链表的增删该查
weixin_44372427的博客
08-21 155
链表的插入又分头部插入和尾部插入。 先说尾部插入：思路如下： 假如一个链表有5个数据，要在3后面插入一个100，先找到3这个节点，再把新节点的下一个节点指向3的下一个节点，再把3的下一个节点指向新节点就完成了插入。注意（2，3步骤不能调换，不然4就丢掉了）。 代码如下： #include<stdio.h> typedef struct date { int date; struct date *next; }stu,*pstu; void printLink(s
链表的增删改查
lllone的博客
03-05 744
链表的增删改查#include &lt;stdio.h&gt;  #include &lt;stdlib.h&gt;  #define len  sizeof(preson)  //测结构体preson的长度，并定义常量，给后面的动态开辟空间提供方便；union clas_position  //共用体：老师和学生的描述不同，学生用班级，老师用职位{ int clas; char position...
【数据结构】链表的增删查改
最新发布
烧鸡配油茶的博客
04-18 580
概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表 中的指针链接次序实现的。注意：1.链式结构在逻辑上是连续的，但在物理上不一定连续2.现实中的结点一般都是从堆上申请出来的3.从堆上申请的空间，是按照一定的策略来分配，两次申请的空间，可能连续，也可能不连续。
学习笔记——链表的增删改查
打不倒的程序猿
05-13 487
C语言的链表章节还是很重要的（因为男），还是挺有意思的，有头有尾，串联起来，不触碰数据结构的双链、栈队列等等，他就是一条蛇，可以进行基本的增删改查的操作，简单记录一下敲的代码。。。 链表的定义 来看看度娘说的：链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 简单说就是物理空间不靠着，逻辑上.
【数据结构】链表-增删查改
weixin_44930735的博客
07-31 2928
链表是一种物理结构上非连续、非顺序的存储结构，数据元素的逻辑是通过链表中的指针链接次序实现的。 链表创建完成后不需要初始化，链表过于简单，就是由一个个的结构体通过指针域串起来的，在不存储数据的时候，可以没有任何节点，即没有结构体，在主函数中将指向结构体的指针置为空就行了。......
链表<list>的增删查等操作
yeleng的博客
11-10 284
list的简单使用， lista1; a1.insert(a1.begin(),6)//向开头添入6 a1.insert(a1.end(),5)//向结尾添入5 a1.pop_fron()t or a1.pop_back() a1.reverse() //意为反转链表 a1.earse()  or a1.remove()  #include #include using
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值