单链表的增、删、查、改

最新推荐文章于 2024-08-24 19:52:40 发布
最新推荐文章于 2024-08-24 19:52:40 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HaloTrriger/article/details/79339345
版权
单链表是一种链式存取的数据结构，用申请的地址存放每个节点，这些地址可能是连续，也可能是不连续的。每个结点的构成：元素(数据元素的映象，data) + 指针(指示后继元素存储位置，next)。通过指针将线性表的数据一个个串联起来，要想访问一个数据，就要知道前一个指针，想知道前一个就要知道前前一个，依次向前找。所以，一般访问是从头指针开始向后查找目标，方向是单向的。
头指针一般是固定的，而尾指针随着链表的增加或删除可能会改变，但是尾指针的后继节点一定是指向空，即NULL的。

下面便是单链表的增、删、查、改操作。

SingleLinkedList.h(头文件)

#pragma once

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

typedef int DataType;

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

SListNode* pStructInit();//结构体指针初始
SListNode* BuySListNode(DataType x);//创建节点
void SListPrint(SListNode* pHead);//打印
void SListDestory(SListNode** ppHead);//销毁

void SListPushBack(SListNode** ppHead, DataType x);//尾插
void SListPopBack(SListNode** ppHead);//尾删
void SListPushFront(SListNode** ppHead, DataType x);//头插
void SListPopFront(SListNode** ppHead);//头删
SListNode* SListFind(SListNode* pHead, DataType x);//查找
void SListInsert(SListNode** ppHead, SListNode* pos, DataType x);//pos前插入
void SListErase(SListNode** ppHead, SListNode* pos);//pos位置删除
void SListAt(SListNode** ppHead, SListNode *pos, DataType x);//替换

SingleLinkedList.c(功能函数的实现)

#include"SingleLinkedList.h"


SListNode* pStructInit()//结构体指针初始
{
    SListNode* pStruct = (SListNode*)malloc(sizeof(SListNode));

    if (pStruct == NULL)
    {
        perror("Initialize fail");
        exit(1);
    }

    pStruct->_next = NULL;

    return pStruct;
}

SListNode* BuySListNode(DataType x)//创建节点
{
    SListNode* tmp = (SListNode*)malloc(sizeof(SListNode));
    if (tmp == NULL)
    {
        perror("Malloc fail");
        exit(1);
    }

    tmp->_data = x;
    tmp->_next = NULL;

    return tmp;
}

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

    SListNode* pnode = pHead->_next;
    while (pnode)
    {
        printf("%d ", pnode->_data);
        pnode = pnode->_next;
    }
    printf("\n");
}

void SListDestory(SListNode** ppHead)//销毁
{
    SListNode* tmp = NULL;

    while (*ppHead)
    {
        tmp = (*ppHead)->_next;
        free(*ppHead);
        (*ppHead) = tmp; 
    }

}

void SListPushBack(SListNode** ppHead, DataType x)//尾插
{
    assert(ppHead);

    SListNode* tmp = *ppHead;

    if (ppHead == NULL)
    {
        *ppHead = BuySListNode(x);
        return;
    }

    while (tmp->_next)
    {
        tmp = tmp->_next;
    }

    tmp->_next = BuySListNode(x);
}

void SListPopBack(SListNode** ppHead)//尾删
{
    assert(ppHead);
    SListNode* tmp = *ppHead;

    if ((tmp->_next)==NULL)//无节点
    {
        return;
    }
    else//有节点
    {
        while (tmp->_next->_next)
        {
            tmp = tmp->_next;
        }
        //将最后一个元素销毁置空
        free(tmp->_next);
        tmp->_next = NULL;
    }

}

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

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

}

void SListPopFront(SListNode** ppHead)//头删
{
    assert(ppHead);

    if ((*ppHead)->_next == NULL)
    {
        return;
    }
    else
    {
        SListNode *tmp = (*ppHead)->_next;
        (*ppHead)->_next = tmp->_next;
        free(tmp);
        tmp = NULL;
    }

}


SListNode* SListFind(SListNode* pHead, DataType x)//查找
{
    SListNode* tmp = pHead;

    while (tmp)
    {
        if (tmp->_data == x)
            return tmp; 
        else
            tmp = tmp->_next;
    }

    return NULL;
}

void SListInsert(SListNode** ppHead, SListNode* pos, DataType x)//pos前插入
{
    assert(ppHead && pos);

    SListNode *p = (*ppHead);
    SListNode *q = BuySListNode(x);

    while (p->_next != pos)
    {
        p = p->_next;
    }
    p->_next = q;
    q->_next = pos;
}

void SListErase(SListNode** ppHead, SListNode* pos)//pos位置删除
{
    assert(ppHead && pos);

    SListNode* tmp = *ppHead;
    while (tmp->_next != pos)
    {
        tmp = tmp->_next;
    }
    tmp->_next = pos->_next;

    free(pos);
    pos = NULL;
}

void SListAt(SListNode** ppHead, SListNode *pos, DataType x)//替换
{
    assert(ppHead && pos);

    SListNode *tmp = *ppHead;

    while (tmp->_next != pos)
    {
        tmp = tmp->_next;
    }
    tmp->_next->_data = x;
}

Test.c(测试)

#include"SingleLinkedList.h"

void TestPushBack(SListNode *list)//尾插
{


    SListPushBack(&list, 1);
    SListPrint(list);

    SListPushBack(&list, 2);
    SListPrint(list);

    SListPushBack(&list, 3);
    SListPrint(list);

    SListDestory(&list);
}

void TestPopBack(SListNode *list)//尾删
{
    SListNode*tmp = list;
    //先插入3个数字
    SListPushBack(&list, 1);
    SListPushBack(&list, 2);
    SListPushBack(&list, 3);
    SListPrint(list);

    list = tmp;
    //开始尾删
    SListPopBack(&tmp);
    SListPrint(tmp);

    SListPopBack(&tmp);
    SListPrint(tmp);

    SListPopBack(&tmp);
    SListPrint(tmp);


    SListDestory(&list);
}

void TestPushFront(SListNode *list)//头插
{


    SListPushFront(&list, 1);
    SListPrint(list);

    SListPushFront(&list, 2);
    SListPrint(list);

    SListPushFront(&list, 3);
    SListPrint(list);

    SListDestory(&list);
}

void TestPopFront(SListNode *list)//头删
{
    SListPushFront(&list, 1);
    SListPushFront(&list, 2);
    SListPushFront(&list, 3);
    SListPrint(list);

    SListPopFront(&list);
    SListPrint(list);//删掉3剩下2和1
    SListPopFront(&list);
    SListPrint(list);//剩下1
    SListPopFront(&list);
    SListPrint(list);//空
    SListPopFront(&list);
    SListPrint(list);//空

    SListDestory(&list);
}


void TestInsert(SListNode *list)//pos前插入
{

    SListNode*pos = NULL;

    //尾插
    SListPushBack(&list, 7);
    SListPushBack(&list, 8);
    SListPushBack(&list, 9);
    //头插
    SListPushFront(&list, 3);
    SListPushFront(&list, 2);
    SListPushFront(&list, 1);

    SListPrint(list);

    pos = SListFind(list,7);
    SListInsert(&list,pos, 6);
    SListPrint(list);

    pos = SListFind(list, 6);
    SListInsert(&list, pos, 5);
    SListPrint(list);

    pos = SListFind(list, 5);
    SListInsert(&list, pos, 4);
    SListPrint(list);

    /*pos = SListFind(list, 20);//因为链表没有20，pos为空指针，在SListInsert函数的断言会报错
    SListInsert(&list, pos, 10);
    SListPrint(list);*/

    SListDestory(&list);
}


void TestErase(SListNode *list)//pos位置删除
{
    SListNode*pos = NULL;

    //尾插
    SListPushBack(&list, 7);
    SListPushBack(&list, 8);
    SListPushBack(&list, 9);
    //头插
    SListPushFront(&list, 3);
    SListPushFront(&list, 2);
    SListPushFront(&list, 1);

    SListPrint(list);

    pos = SListFind(list,1);
    SListErase(&list, pos);
    SListPrint(list);

    pos = SListFind(list, 2);
    SListErase(&list, pos);
    SListPrint(list);

    pos = SListFind(list, 3);
    SListErase(&list, pos);
    SListPrint(list);

    pos = SListFind(list, 7);
    SListErase(&list, pos);
    SListPrint(list);

    pos = SListFind(list, 8);
    SListErase(&list, pos);
    SListPrint(list);

    pos = SListFind(list, 9);
    SListErase(&list, pos);
    SListPrint(list);

    SListDestory(&list);
}


void TestFind(SListNode *list)//查找
{
    SListPushBack(&list, 1);
    SListPushBack(&list, 2);
    SListPushBack(&list, 3);

    //数据存在，打印该数据；查找不存在数据会发生异常
    printf("%d\n", SListFind(list, 3)->_data);
    printf("%d\n", SListFind(list, 2)->_data);
    printf("%d\n", SListFind(list, 1)->_data);
    //printf("%d\n", SListFind(list, 0)->_data);//链表内没有数据data存放0，因此返回NULL，而用空指针访问data数据会异常

    SListDestory(&list);
}



void TestAt(SListNode *list)//替换
{
    SListNode*pos = NULL;

    //头插
    SListPushFront(&list, 3);
    SListPushFront(&list, 2);
    SListPushFront(&list, 0);

    //尾插
    SListPushBack(&list, 4);
    SListPushBack(&list, 8);
    SListPushBack(&list, 9);

    SListPrint(list);

    pos = SListFind(list, 0);
    SListAt(&list, pos, 1);
    SListPrint(list);

    pos = SListFind(list, 8);
    SListAt(&list, pos, 5);
    SListPrint(list);

    pos = SListFind(list, 9);
    SListAt(&list, pos, 6);
    SListPrint(list);

    SListDestory(&list);
}


int main()//想要测试哪个，则放开前面的双斜线
{
    SListNode *list = pStructInit();

    //TestPushBack(list);//尾插
    //TestPopBack(list);//尾删
    //TestPushFront(list);//头插
    //TestPopFront(list);//头删
    //TestInsert(list);//pos前插入
    //TestErase(list);//pos位置删除
    //TestFind(list);//查找
    //TestAt(list);//替换

    system("pause");
    return 0;
}

最后，那里要是写错了，或者不懂的地方，欢迎评论或者私信给我，谢谢。

立 夏
关注
专栏目录
Python如何创建一个单链表，以及实现单链表的增，删，改，查操作，以及对单链表的排序功能
Idoit_z的博客
07-02 1509
标题Python如何创建一个单链表，以及实现单链表的增，删，改，查操作，以及对单链表的排序功能 #功能: 实现单链表的构建和功能操作 #定义单链表的类 class Node: """ 思路:将自定义的类视为节点的生成类,实例对象中 包含数据部分和指向下一个节点的next """ def __init__(self, val, next=None...
【数据结构】单链表的增、删、查、改等
weixin_38682277的博客
03-26 581
今天来写一下单链表的增删查改。先来说一下链表的分类：链表由特点的不同分为：      （1）单向链表；   （2）双向链表      （1）不带环；      （2）带环      （1）不带头结点；（2）带头结点   三种特点结合，总共有八种链表，其中 [ 单向、不带环、不带头结点 ]链表和 [ 双向、带环、带头结点 ]链表 比较常见。今天要写的单链表为：单向、不带环、不带头结点的链表。下面上代...
#数据结构# 单链表的实现1（C语言）
最新发布
Asuiiiyi的博客
08-24 1055
即为第二个结点的地址，第二个结点中的next为第三个结点的地址......直到第三个结点以后,如果没有新的结点,则这个结点的next指向空,即。在SListNode结构体中，存放一个SListNode的结构体指针，这个指针即为指向下一位结点的地址，命名为“next”。先找头结点，通过头结点找下一个结点，找到一个，就打印一个，直到最后一个结点为止。简单来说可以说为“一环扣一环”，每个结点的数据都有着联系下一个结点的方式。的结点可以称为头结点，该结点中的next为。最后，由于是新的结点,
单链表的增、删、改、查
MrWangyu的专栏
05-22 261
  单链表的增、删、改、查（原创）     由 王宇 原创并发布：   以下代码均在linux 环境下，gcc v4.5 编译调试通过。   #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; struct node { int data; struct node *next; }*head; v...
初夏小谈：单链表的增/删/查/改操作（完整版）
Scissors_初夏的博客
12-04 523
链表谈到它我就想起了小时候吃的一种糖（我们把它叫链子糖）。它虽然总是会黏在牙齿上，但超甜的，让我们既爱又恨，所以总会联想起它。 哈哈^_^....... 回到正文今天的链表。这次是第一次完整的写一个链表。链表的思想简单，但真的自己一个一个实现还是遇到了不少的问题。其中一个重大的错误就是我经常会拿着指向头指针的指针去修改链表，这样会导致的链表不是想要的。犯这样的错误在于我总以为传值（传的是...
单向链表(四) 修改指定节点的数据值、逆序输出
wwkaven的专栏
08-01 4525
1、因为修改比较好理解，就不再累述了，直接贴出
Java单链表增删改查的实现
08-15
下面我们将详细探讨如何在Java中实现单链表的增、删、改、查功能，以及如何进行选择排序、冒泡排序和反转排序。 1. **单链表的定义**： - 单链表的每个节点通常包括两部分：数据域（存储元素）和指针域（存储下一...
java实现单链表增删改查的实例代码详解
10-16
以上就是对单链表进行增删改查操作的详细实现。通过这些方法，我们可以对链表进行各种操作，实现对链表数据的灵活管理和处理。在实际应用中，单链表是一种非常重要的数据结构，它被广泛应用于各种算法和程序设计中。...
单链表的增删改查
m0_62591999的博客
08-11 199
单链表的增删改查C++
单链表--增删改查，头插尾插，清空销毁
浅然的专栏
09-29 557
#include <stdio.h> #include <malloc.h> #define ok 1 #define error 0 typedef int Elemtype; typedef struct LNode{ Elemtype data; struct LNode *next; }LNode,*LinkLi
【C语言】单链表的增查
cute_Niu的博客
09-19 255
单链表的基本操作 初始化 void SListInit(SListNode **ppFirst) { assert(ppFirst != NULL); *ppFirst = NULL; } 从头部插入 首先需要开辟空间，因为在以后的操作中还需要动态开辟空间故把开辟空间独立封装为一个函数。 开辟空间函数 static SListNode* CreatNode(DataType data) { ...
顺序表和链表对文件的增删改查
10-27
顺序表和链表对文件的增删改查.数据库内的存储数据的数据类型之一。
【rush】单链表的增、删、改、查操作
qq_43456605的博客
09-16 397
注意代码中的注释中的指针并非与c++以及c中的指针一样，Java中是不存在指针这个概念的，之所以将其称为指针是为了加深对链表这一重要数据结构的理解。 package chailong; import java.util.Scanner; class Point //结点类 { Point next; //指针域 int data; ...
C语言实现链表的基本操作(增，删，查，改等等)
热门推荐
Damn_Yang的博客
11-03 11万+
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。 每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 LinkList.h #ifndef __LINKLIST_H__ #define __LINKLIST_H__ ...
双链表（double_linked_list）:（增、删、改、查、逆置）的C++的例子，稍微改一下，就成C。
CIT_RWC的专栏
07-17 1312
1 #include   2 #include   3 #include   4 using namespace std;   5   6 struct dl_node   7 {   8         char name[20];   9         struct dl_node *pre, *next;  10 };  11 typedef dl_node d
逆置单链表、替换法之无头单链表的插入与删除
The Laughing Uncle的博客
09-16 308
1. 从尾到头打印单链表 我们知道，单链表只能够通过前面结点来找到后一个结点，不能直接通过后一个结点来找前一个结点，所以如何先打印后面的元素，在打印前面的元素。可以想到运用递归，设头结点为first 第一次函数调用：first-&amp;gt;next 第二次函数调用：first-&amp;gt;next-&amp;gt;next 第三次函数调用：first-&amp;gt;next-&amp;gt;next-&amp;gt;next...
单链表（增删）
qq_44404616的博客
11-03 162
主代码 1、定义单链表类 public class MySignal2 { private ListNode2 head; MySignal2() { this.head = null; } public ListNode2 getHead() { return head; } public void setHe...
单链表增删查改的实现（c语言描述）
未见花闻的博客
06-16 857
内容导读 （一） 链表的概念 （二）单链表增删查改的实现 单链表增删查改头文件声明说明 单链表的特点 单链表新结点的申请 单链表的插入操作 单链表结点的删除 单链表元素查找与替换 单链表的打印 单链表的销毁 单链表的长度 单链表的整体创建
火车售票单链表增删改查
06-02
好的，我可以帮你解答这个问题。 首先，我们可以定义一个火车售票的节点类，包含以下属性： - 车次号 - 出发站点 - 到达站点 - 出发时间 - 到达时间 ...这样，我们就实现了火车售票单链表的增删改查功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值