数据结构单链表（C语言实现）

已于 2023-03-12 17:31:48 修改
阅读量146 收藏
点赞数 2
分类专栏： 数据结构 文章标签： c语言 数据结构 Powered by 金山文档
于 2023-02-27 21:26:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65014490/article/details/129248872
版权

1.链表的概念及结构

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

2.单链表的实现

2.1创建一个链表的结构

typedef int SLTDataType;

typedef struct SListNode
{
    SLTDataType data;
    struct SListNode* next;
}SLTNode;

其中我们可以定义储存的数据类型，然后创建一个结构体，包含下一个节点的指针。

2.2增加一个节点

SLTNode* BuySLTNode(SLTDataType x)
{
    SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
    if (newnode == NULL)
    {
        perror("malloc fail");
        

    }
    newnode->data = x;
    newnode->next = NULL;

    return newnode;
}

我们创建一个节点，存入需要的存放的值。这个函数被调用时就可以增加一个节点。比如在尾部插入一个节点或则在头部插入一个节点都需要这个函数，比较方便。

2.3在尾部插入一个节点（尾插）

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
    SLTNode* newnode = BuySLTNode(x);
    if (*pphead == NULL)
    {
        *pphead = newnode;
    }
    else
    {
        SLTNode* tail = *pphead;
        while (tail->next != NULL)
        {
            tail = tail->next;
        }
        tail->next = newnode;
    }
}

注意我们在接下来需要改变链表头的指向的话就需要传入二级指针，这样可以通过解引用改变其指向。

如果该链表是空的，我们就将链表头指向创建的节点。

        SLTNode* tail = *pphead;//找到链表的尾部
        while (tail->next != NULL)
        {
            tail = tail->next;
        }

2.4在头部插入一个节点（头插）

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
    SLTNode* newnode = BuySLTNode(x);
    if (*pphead == NULL)
    {
        *pphead = newnode;
    }
    else
    {
        newnode->next = *pphead;
        *pphead = newnode;
    }
}

2.5在尾部删除一个节点（尾删）

void SLTPopBack(SLTNode** pphead)
{
    assert(pphead);
    if ((*pphead)->next == NULL)
    {
        free(*pphead);
        *pphead=NULL;
    }
    else
    {
        SLTNode* prev = NULL;
        SLTNode* tail = *pphead;
        while (tail->next != NULL)
        {
            prev = tail;
            tail = tail->next;
        }
        free(tail);
        tail = NULL;
        prev->next = NULL;
    }
}

在删除尾部节点时，使用了一个非常巧妙的方法，就是将prev比tail的走的少一布，这样释放掉tail指向的节点。

2.6在头部删除一个节点（头删）

void SLTPopFront(SLTNode** pphead)
{
    if (*pphead ==NULL)
    {
        return;
    }
    else
    {
        SLTNode* first = *pphead;
        *pphead = first->next;
        free(first);
        first = NULL;
    }
}

2.7在链表中寻找一个节点

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
    SLTNode* find = phead;
    
    while (find != NULL)
    {
        if (find->data == x)
        {
            return find;
        }
        find = find->next;
    }
    return NULL;

}

这里注意我们要注意不要改变链表头的指向，我们就不需要使用二级指针。

2.8删除一个节点

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
    //头删
    //非头删
    assert(pos);
    assert(pphead);
    if (*pphead == pos)
    {
        SLTNode* first = *pphead;
        *pphead = first->next;
        free(first);
        first = NULL;
    }
    else
    {
        SLTNode* cur = *pphead;
        
        while (cur->next != pos)
        {
            
            cur = cur->next;
            assert(cur);
        }
        cur->next = pos->next;
        free(pos);
    }
}

这里就需要分为头删和非头删，分别实现两个功能即可。

2.9修改一个节点的内容

void SLTModify(SLTNode* phead, SLTNode* pos, SLTDataType x)
{
    SLTNode* cur = phead;
    while (cur != pos)
    {
        cur = cur->next;
        assert(cur);
    }
    cur->data = x;

}

就是找到该位置，将data改变。

2.10在一个节点之前插入一个节点

void SLTInsertFront(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
    SLTNode* newnode = BuySLTNode(x);
    if (*pphead == pos)
    {
        newnode->next = *pphead;
        *pphead = newnode;
    }
    else
    {
        SLTNode* cur = *pphead;
        while (cur->next != pos)
        {
            cur = cur->next;
            assert(cur);
        }
        cur->next = newnode;
        newnode->next = pos;
    }
}

2.11在一个节点之后插入一个节点

void SLTInsertBack(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
    assert(pos);
    assert(pphead);
    SLTNode* newnode = BuySLTNode(x);
    SLTNode* cur = *pphead;
    while (cur != pos)
    {
        cur = cur->next;
        assert(cur);
    }
    
    newnode->next = pos->next;
    pos->next = newnode;
    
    
}

2.12销毁链表

在销毁时我们要知道节点必须要一个一个销毁

void SLTDestroy(SLTNode** pphead)
{
    assert(pphead);
    SLTNode* cur = *pphead;
    while (cur)
    {
        SLTNode* next = cur->next;
        free(cur);
        cur = next;
    }
    *pphead = NULL;
}

3.总代码

3.1 SList.c

#define  _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

void SLTPrint(SLTNode* phead)
{
    SLTNode* cur = phead;
    while (cur!=NULL)
    {
        printf("%d->", cur->data);
        cur = cur->next;
    }
    printf("NULL\n");
}

SLTNode* BuySLTNode(SLTDataType x)
{
    SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
    if (newnode == NULL)
    {
        perror("malloc fail");
        

    }
    newnode->data = x;
    newnode->next = NULL;

    return newnode;
}




void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
    SLTNode* newnode = BuySLTNode(x);
    if (*pphead == NULL)
    {
        *pphead = newnode;
    }
    else
    {
        SLTNode* tail = *pphead;
        while (tail->next != NULL)
        {
            tail = tail->next;
        }
        tail->next = newnode;
    }
}


void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
    SLTNode* newnode = BuySLTNode(x);
    if (*pphead == NULL)
    {
        *pphead = newnode;
    }
    else
    {
        newnode->next = *pphead;
        *pphead = newnode;
    }
}


void SLTPopBack(SLTNode** pphead)
{
    assert(pphead);
    if ((*pphead)->next == NULL)
    {
        free(*pphead);
        *pphead = NULL;
    }
    else
    {
        SLTNode* prev = NULL;
        SLTNode* tail = *pphead;
        while (tail->next != NULL)
        {
            prev = tail;
            tail = tail->next;
        }
        free(tail);
        tail = NULL;
        prev->next = NULL;
    }
}


void SLTPopFront(SLTNode** pphead)
{
    if (*pphead == NULL)
    {
        return;
    }
    else
    {
        SLTNode* first = *pphead;
        *pphead = first->next;
        free(first);
        first = NULL;
    }
}


SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
    SLTNode* find = phead;
    
    while (find != NULL)
    {
        if (find->data == x)
        {
            return find;
        }
        find = find->next;
    }
    return NULL;

}

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
    //头删
    //非头删
    assert(pos);
    assert(pphead);
    if (*pphead == pos)
    {
        SLTNode* first = *pphead;
        *pphead = first->next;
        free(first);
        first = NULL;
    }
    else
    {
        SLTNode* cur = *pphead;
        
        while (cur->next != pos)
        {
            
            cur = cur->next;
            assert(cur);
        }
        cur->next = pos->next;
        free(pos);
    }
}

void SLTModify(SLTNode* phead, SLTNode* pos, SLTDataType x)
{
    SLTNode* cur = phead;
    while (cur != pos)
    {
        cur = cur->next;
        assert(cur);
    }
    cur->data = x;

}


void SLTInsertFront(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
    SLTNode* newnode = BuySLTNode(x);
    if (*pphead == pos)
    {
        newnode->next = *pphead;
        *pphead = newnode;
    }
    else
    {
        SLTNode* cur = *pphead;
        while (cur->next != pos)
        {
            cur = cur->next;
            assert(cur);
        }
        cur->next = newnode;
        newnode->next = pos;
    }
}


void SLTInsertBack(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
    assert(pos);
    assert(pphead);
    SLTNode* newnode = BuySLTNode(x);
    SLTNode* cur = *pphead;
    while (cur != pos)
    {
        cur = cur->next;
        assert(cur);
    }
    
    newnode->next = pos->next;
    pos->next = newnode;
    
    
}

void SLTDestroy(SLTNode** pphead)
{
    assert(pphead);
    SLTNode* cur = *pphead;
    while (cur)
    {
        SLTNode* next = cur->next;
        free(cur);
        cur = next;
    }
    *pphead = NULL;
}

3.2 SList.h

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

#pragma once

typedef int SLTDataType;

typedef struct SListNode
{
    SLTDataType data;
    struct SListNode* next;
}SLTNode;

void SLTPrint(SLTNode* phead);

void SLTPushBack(SLTNode** pphead, SLTDataType x); 
void SLTPushFront(SLTNode** pphead, SLTDataType x);


void SLTPopBack(SLTNode** pphead);
void SLTPopFront(SLTNode** pphead);

SLTNode*  SLTFind(SLTNode* phead, SLTDataType x);

void SLTErase(SLTNode** pphead, SLTNode*pos);



void SLTModify(SLTNode* phead, SLTNode* pos, SLTDataType x);


void SLTInsertFront(SLTNode** pphead, SLTNode* pos, SLTDataType x);

void SLTInsertBack(SLTNode** pphead, SLTNode* pos, SLTDataType x);

void SLTDestroy(SLTNode** pphead);

GO1ING
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构单链表实现（C语言）
m0_68081211的博客
04-04 1497
#include<stdio.h> #include<stdlib.h> typedef struct LNode { int data; struct LNode *next; } LNode , *LinkList; //初始化一个带头结点的单链表 bool InitList(LinkList L) { L = (LNode *)malloc(sizeof(LNode)); if (L == NULL) return false; //内存没分配成功.
数据结构 - 单链表（C语言实现）
C橘子
04-07 814
一. 链表的定义   链表是动态分配存储空间的链式存储结构。   其包括一个“头指针”变量，其中第0个结点称为整个链表的头结点，头结点中存放一个地址，该地址指向一个元素，头结点一般不存放具体数据，只是存放第一个结点的地址。   链表中每一个元素称为“结点”，每个结点都由两部分组成：存放数据元素的数据域和存储直接后继存储位置的指针域。指针域中存储的即是链表的下一个结点存储位置，是一个指针。多个结点链...
单链表中二级指针的使用以及单链表的增删查改操作
Lee贤的博客
04-21 1267
本文主要介绍了链表带头节点和不带头节点的两种方式的基本介绍和实现及二级指针的用法原理
链表操作总结
炎溟墨的博客
09-05 470
文章目录如何实现单链表的增删操作?单链表的定义单链表的插入操作(增)单链表的删除操作如何删除链表中重复的数据如何找出单链表中的倒数第K个元素如何实现链表的反转如何从尾到头输出单链表如何寻找单链表的中间结点如何检测链表是否有环怎么找环入口如何在不知道头指针的情况下删除指定节点如何判断两个链表相交如果两个链表相交,找出相交的第一个结点 如何实现单链表的增删操作? 单链表的定义 //单链表结点 clas...
【数据结构】单链表的实现（C语言）
( :3 )
09-23 5894
单链表是线性表链式储存的一种形式，其中的结点一般含有两个域，一个是存放数据信息的info域，另一个是指向该结点后继结点存放地址的指针next域。一个单链表必须要有一个首指针指向链表中的第一个结点。 单链表要掌握以下几种操作： 1、建立一个空的单链表。 2、输出单链表中个结点的值。 3、在单链表中查找第i个结点。 4、在单链表的第i个结点后插入一个值为x的新结点。 5、在单链表中删除一个...
单链表（C++实现）
qq_39559641的博客
04-07 3937
一、实验要求 (1).尾插法创建单链表，打印创建结果。 (2).头插法创建单链表，打印创建结果。 (3).销毁单链表。 (4).求链表长度。 (5).求单链表中第i个元素（函数），若不存在，报错。 (6).在第i个结点前插入值为x的结点。 (7).链表中查找元素值为x的结点，成功返回结点指针，失败报错。 (8).删除单链表中第i个元素结点。 (9).在一个递增有序的单链表L中插...
【 数据结构 】单链表的实现 - 详解（C语言版）
热门推荐
上上谦. 的博客
03-22 1万+
前言 简单用C语言来描述数据结构中的单链表，本文实现的只是简单的无头单链表，包括单链表的增加数据，删除数据，查找指定数据，修改指定数据，也就是简单的增删查改等操作。
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
数据结构-C语言实现单链表-数据结构学习
05-26
C语言实现的数据结构中的单链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对链表边界的判定 实现了以下功能： 创建单链表 向顺序表中插入元素(头插法，尾插...
严蔚敏数据结构全套C语言实现
05-21
严蔚敏教授的教材详细介绍了这些数据结构的概念、特性以及C语言实现方法，并提供了大量示例代码，是学习和理解数据结构的好资源。通过学习这套资料，读者不仅可以掌握数据结构的基本原理，还能提升C语言编程能力，为...
数据结构单链表（C语言）
03-27
通过c语言实现单链表的建立、初始化、尾插法插入结点、头插法插入结点、数据的查找、删除、在指定位置插入结点、在指定位置删除结点、打印输出数据、统计单链表的长度等功能。
C语言数据结构单链表的增删查改
04-29
C语言数据结构单链表的增删查改
【数据结构】【C语言】------ 单链表
m0_63601181的博客
05-14 4164
前言 大家好，我是Abert。 这篇文章和大家分享用C语言实现数据结构中的单链表。 单链表可以看作是“拆分开”的顺序表。在顺序表的基础上，单链表做了一些优化，但同时也丧失了一些顺序表有的功能。 我们一起来学习单链表吧！！！ 文章目录 一、单链表的讲解 二、程序基本框架的搭建与讲解 2.1 文件的创建 2.2 变量的创建 三、各种功能的实现及逻辑关系的讲解 3.1 尾插 3.2 头插 3.3 尾删 ...
数据结构——链表（C语言实现）
yyf的博客
05-21 2536
描述 用C语言实现数据结构中链表的操作 代码实现 #include &lt;stdio.h&gt; #include &lt;malloc.h&gt; typedef struct num { int data; struct num *next; }node; int main() { node *p1,*p2,*head; int i,m,n,count=1; scanf(...
数据结构学习笔记——线性表之单链表（c语言实现）
luotuoxiansheng的博客
10-31 4992
1.概念 链式存储结构：是指把数据元素存放在任意内存未被占用的存储单元里，这组存储单元可以是连续的，也可以是不连续的。 大概就是这样： 因此，为了表示每个数据元素a1，与其直接后继数据元素 a2 之间的逻辑关系，对数据元素a来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置）。 对此有如下几个概念： 数据域 指针域 指针(链) 头指针 存储数据...
数据结构-单链表(C语言代码)
weixin_50246370的博客
08-05 303
数据结构纯属新手，小白一枚，欢迎批评指正！ 直接上代码OVO！ 定义结构体 typedef struct Node { int data; //数据域 struct Node* next; //指针域 }Node; 单链表只有数据域和指向下一个结点的指针域。 创建链表 //创建链表 Node* initList() { Node* L = (Node*)malloc(sizeof(Node)); //创建头指针 L->data = 0; L->next = NULL;//刚
数据结构之单链表操作(c)
Roc Bird的博客
06-06 239
单链表操作(c语言版) 数据结构 单链表分为两种,一种是带头节点是NULL的单链表,一种是头节点不是NULL的单链表 具体实现(可运行) 了解它的数据结构后,根据它特有的数据结构可以进行各种操作. #include<stdio.h> #include<stdlib.h> typedef int ElemType; //链表结构 typedef s...
C++之break / continue陈述九州地址QA98嚸CC语言
最新发布
hdtmd的博客
07-07 466
关键字 break 用于跳出 switch 陈述或跳出回圈。以下程式示范switch陈述中使用break编译后执行，结果如下此例在case 1、case 2之后使用break陈述由于0就符合选项，使得执行完case 0的部份后，由于这里没有break陈述，因此程式会继续执行底下所有的陈述，直到遇上break或到右大括弧为止。以下程式示范在回圈中使用编译后执行，结果如下这里利用if判断控制变数i是否等于整数5，若是等于5就用break跳出for回圈，因此输出只有印到4为止。
数据结构单链表的实现代码c语言
05-31
以下是单链表的C语言代码实现，包括建立线性表、删除、查找、插入元素等操作： ```c #include #include // 单链表结点的定义 typedef struct LNode{ int data; // 数据域 struct LNode *next; // 指针域，指向下...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值