【数据结构】Singly-Linked-List 单链表（更新时间：2016-04-07）

最新推荐文章于 2021-08-04 18:42:45 发布
最新推荐文章于 2021-08-04 18:42:45 发布
阅读量682 收藏
点赞数
分类专栏： 学习笔记 文章标签： 数据结构 单链表 链表 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pjzck/article/details/51075572
版权

Singly-Linked-List 单链表

趁着状态还不错，而且昨天刚刚发了线性表，现在赶紧来一发简单的单链表

链表从广义上来讲，属于采用指针动态化存储的线性表，在每次添加节点的时候，它向内存申请一 块 存储空间，在这一块存储空间内用于存储指针域和数值域。指针域 用于将链表的各个节点串联成一个链表，数值域 用于存储所需要存储的数据。
链表在逻辑上来说仍然属于线性表的一种，只是在存储形式上摆脱了是用数组存储而带来的存储上限的限制。理论上，链表的存储空间是无限的，但是由于电脑内存的限制，依旧会由于同时存在过多的链表节点而使得无法继续开辟空间来增加新的节点到链表中。

根据链表不同的连接方式，有以下几种常见的链表：

  • 单向链表
  • 双向链表
  • 十字链表

在这里，Doge向大家简单的介绍一下单链表的相关基础知识和操作。

单链表 是指该链表的存储结构中所存在的指针域仅存在一个指向下一个节点的指针，通过该指针简单的将整个链表链接起来。
示意图如下：
示意图

对于单链表，依旧先给出它的结构声明：

struct ListNode;                            //定义链表节点结构
typedef struct ListNode *PtrToNode;         //定义结点指针类型
typedef PtrToNode LinkedList;               //定义链表头节点类型
typedef PtrToNode LLNode;                   //定义节点类型
typedef int ElementType;                    //定义数据类型

struct ListNode                             //节点结构
{
    ElementType Element;                    //数值域
    LLNode Next;                            //指针域
};

Doge 使用的单链表中采用了哑节点(DummyHead)，即在链表的头部加入一个额外的节点来方便之后对于整个链表的数据操作等：

LinkedList Initial( void )                                  //初始化
{
    LinkedList L;

    L = ( LinkedList ) malloc ( sizeof( ListNode ) );       //分配头节点空间
    L->Next = NULL;
    return L;
}

对于链表，最基础的操作之一也是 插入(Insert) 操作，由于链表中不存在数据位置一说，因此 Doge 在这里只说一说简单插入而不使用定点插入，有兴趣的读者可以自行实现。对于简单插入，我们将数据直接链接到表头的后面来实现：

LinkedList Insert( LinkedList L, ElementType X )            //插入
{
    LLNode P;

    P = ( LLNode ) malloc ( sizeof( ListNode ) );           //分配插入节点的空间
    P->Element = X;                                         //节点数值域赋值
    P->Next = L->Next;                                      //将头节点的指针接到插入节点之后
    L->Next = P;                                            //将插入节点链接回到链表
    return L;
}

在链表中，由于许多操作涉及到指针的移动，因此我们在查找数据的时候往往是去寻找它的前驱结点，来简化我们对于许多后续操作。同样，对于 查找(Find) 我们同样是借助 查找前驱(FindPrevious) 来实现：

LLNode FindPrevious( LinkedList L, ElementType X )          //查找前驱
{
    LLNode P = L;                                           //游标初始化

    while( P->Next != NULL && P->Next->Element != X )       //遍历查找指定元素
        P = P->Next;
    if( P->Next == NULL )                                   //未找到指定元素，返回NULL
        return NULL;
    else                                                    //找到则返回前驱
        return P;
}

LLNode Find( LinkedList L, ElementType X )                  //查找
{
    LLNode P = FindPrevious( L, X );                        //使用查找前驱函数

    if( P == NULL )                                         //未找到
    {
        cout << X << " is not found in the LinkedList!\n";
        return NULL;
    }
    else                                                    //找到则返回指定元素节点
        return P->Next;
}

删除指定元素，同样调用查找前驱函数，如果存在返回值则删除节点并且释放存储空间：

LinkedList Delete( LinkedList L, ElementType X )            //删除
{
    LLNode P = FindPrevious( L, X );                        //使用查找前驱函数

    if( P == NULL )                                         //返回值为NULL
    {
        cout << X << " is not found in the LinkedList!\n";
        return L;
    }
    else                                                    //删除节点并释放存储空间
    {
        LLNode tmp = P->Next;
        P->Next = tmp->Next;
        free( tmp );
        return L;
    }
}

我们在是用链表的时候有时候可以将原来存在的链表清空并重新使用这个表的时候就需要用到清空函数，同样，在删除链表的时候我们也需要先把链表清空：

LinkedList MakeEmpty( LinkedList L )                        //清空链表
{
    LLNode tmp = L->Next;                                   //游标指向实际存储表的头
    while( tmp != NULL )                                    //遍历清空链表
    {
        LLNode tmpp = tmp->Next;
        free( tmp );                                        //释放存储空间
        tmp = tmpp;
    }
    return L;
}

void Delete( LinkedList L )                                 //删除表
{
    L = MakeEmpty( L );                                     //清空表
    free(L);                                                //删除表头
}

下面附上整合之后的C++代码：（未做实际程序测试，仅提供数据结构模板）

#include <cstdlib>
#include <iostream>

using namespace std;

struct ListNode;                            //定义链表节点结构
typedef struct ListNode *PtrToNode;         //定义结点指针类型
typedef PtrToNode LinkedList;               //定义链表头节点类型
typedef PtrToNode LLNode;                   //定义节点类型
typedef int ElementType;                    //定义数据类型

struct ListNode                             //节点结构
{
    ElementType Element;                    //数值域
    LLNode Next;                            //指针域
};

LinkedList  Initial( void );
int         IsEmpty( LinkedList L );
LinkedList  Insert( LinkedList L, ElementType X );
LLNode      Find( LinkedList L, ElementType X );
LLNode      FindPrevious( LinkedList L, ElementType X );
LinkedList  Delete( LinkedList L, ElementType X );
LinkedList  MakeEmpty( LinkedList L );
void        Delete( LinkedList L );
/*****************************************/
int main()
{}
/*****************************************/
LinkedList Initial( void )                                  //初始化
{
    LinkedList L;

    L = ( LinkedList ) malloc ( sizeof( ListNode ) );       //分配头节点空间
    L->Next = NULL;

    return L;
}

int IsEmpty( LinkedList L )
{
    return ( L->Next == NULL );
}

LinkedList Insert( LinkedList L, ElementType X )            //插入
{
    LLNode P;

    P = ( LLNode ) malloc ( sizeof( ListNode ) );           //分配插入节点的空间
    P->Element = X;                                         //节点数值域赋值
    P->Next = L->Next;                                      //将头节点的指针接到插入节点之后
    L->Next = P;                                            //将插入节点链接回到链表
    return L;
}

LLNode FindPrevious( LinkedList L, ElementType X )          //查找前驱
{
    LLNode P = L;                                           //游标初始化

    while( P->Next != NULL && P->Next->Element != X )       //遍历查找指定元素
        P = P->Next;
    if( P->Next == NULL )                                   //未找到指定元素，返回NULL
        return NULL;
    else                                                    //找到则返回前驱
        return P;
}

LLNode Find( LinkedList L, ElementType X )                  //查找
{
    LLNode P = FindPrevious( L, X );                        //使用查找前驱函数

    if( P == NULL )                                         //未找到
    {
        cout << X << " is not found in the LinkedList!\n";
        return NULL;
    }
    else                                                    //找到则返回指定元素节点
        return P->Next;
}

LinkedList Delete( LinkedList L, ElementType X )            //删除
{
    LLNode P = FindPrevious( L, X );                        //使用查找前驱函数

    if( P == NULL )                                         //返回值为NULL
    {
        cout << X << " is not found in the LinkedList!\n";
        return L;
    }
    else                                                    //删除节点并释放存储空间
    {
        LLNode tmp = P->Next;
        P->Next = tmp->Next;
        free( tmp );
        return L;
    }
}

LinkedList MakeEmpty( LinkedList L )                        //清空链表
{
    LLNode tmp = L->Next;                                   //游标指向实际存储表的头
    while( tmp != NULL )                                    //遍历清空链表
    {
        LLNode tmpp = tmp->Next;
        free( tmp );                                        //释放存储空间
        tmp = tmpp;
    }
    return L;
}

void Delete( LinkedList L )                                 //删除表
{
    L = MakeEmpty( L );                                     //清空表
    free(L);                                                //删除表头
}
KuroNeko黑猫
关注
专栏目录
C++实现单链表(Singly-Linked List)追加、遍历、删除
wupeak的专栏
01-27 1728
#include using namespace std; struct Node { int data; struct Node* next; }; class List { Node* head; public: List() { head = NULL;} void Print(); int GetSize(); void Append(int addData); voi
SinglyLinkedList
12-19
实现带头结点的单链表类List，测试类中的每一个函数; 实现用户类User，包括用户名，密码两个字段 实现系统类MySystem, 包括bool login(User user), bool logout(User user)两个方法;
单链表操作_更新中
smithdoudou88的专栏
11-04 801
#include "stdafx.h" #include using namespace std; typedef struct Node{ int data; struct Node *next; }LinkList; /* //链表的建立（无头结点）：尾插法——插入元素后为正序； LinkList *createTailList() { LinkList *s
单链表(Singly Linked List)
Catherine的笔记
03-24 4053
单链表(Singly Linked List) 1. 单链表的概念 1.1 单链表的定义 单链表是线性表的链式存储表示。 1.2 单链表的结点结构 单链表的结点包括两个部分：数据域和指针域。 (1)数据域(data)，用于存储该结点的数据元素，数据元素类型由应用问题决定。 (2)指针域(link)，用于存放一个指针，该指针指向下一个结点的开始存储地址。 单链表的结点结构示意图： 1.3 单链表中各结点
Glib学习（1） 单链表 Singly-Linked Lists
andylauren的专栏
05-08 2341
http://web.mit.edu/barnowl/share/gtk-doc/html/glib/index.html
算法总结-链表（正在更新）
欧阳惜竹的博客
05-13 391
参考：https://mp.weixin.qq.com/s/mpXLtn0iQam80sFA8QG7vw 文章目录简述链表的特点和适用场景链表特点链表适用场景实例解析题目1：旋转链表题目2：反转链表题目3：环形链表 简述 链表是一个重要的数据结构，常见的链表又分为单向链表和双向链表，各自都有很多应用场景。下面一起来看看吧： 链表的特点和适用场景 链表特点 （1）链表是一种特殊的存储结构，物理存储空...
Write Queue ADT using a singly-linked list in c language 这是什么意思 adt是干嘛用的
最新发布
10-24
将Write Queue使用单链表实现（singly-linked list）在C语言中，意味着你需要创建一个结构体来代表链表节点，包含数据以及指向下一个节点的指针。Write Queue的主要操作可能会包括： 1. 插入操作（Enqueue）：在...
Singly_Linked_List.rar
05-19
单链表是计算机科学中数据结构的基础之一，它在存储和处理有序或无序数据时发挥着重要作用。本文将深入探讨单链表的概念，以及如何使用C语言和C++实现其基本操作，如初始化、查找、插入、删除和展示。 首先，让我们...
danlianbiao.rar_singly linked list
09-21
在这个"danlianbiao.rar_singly linked list"的资源中，我们将深入探讨如何创建、操作和管理这种数据结构。 首先，我们来看"建立(头插法)"部分。头插法是向单链表的头部添加新节点的方法。在创建一个空链表时，通常...
SINGLY-LL.rar_The Program
09-22
单链表（Singly Linked List）是一种基础且重要的数据结构，它在计算机科学中被广泛应用于各种算法和数据管理场景。在这个程序中，我们将深入探讨单链表的概念、实现细节以及其常见操作。 单链表是由一系列节点构成...
Queue学习之Singly-Linked List
LYH66的专栏
05-27 2452
早就听说了libevent这个开源网络库的大名，刚好最近时间比较闲，所以就拜读一下。计划是从0.1版本（最早版）开始看起，因为我想看一下libevent成长历史和网络通信方面的相关技术发展。在libevent0.1版本中，核心就是event这个结构体了。而这个结构体中又用了sys/queue.h中的TAIL QUEUES。因此打算先学习一下sys/queue.h中提到的几个queue。本文将会讲解一
链表，单向链表的创建，插入，更新，删除操作
qq_40823802的博客
08-09 469
总结： 链表是以节点的方式来存储，是链式存储。 每个节点包含data域，next域：指向下一个节点 链表的各个节点不一定是连续存储。 链表分类：带头节点的链表和没有头结点的。根据实际的需求来确定。 单链表（带头结点）逻辑结构示意图： 添加（创建） 1.先创建一个head头结点，作用就是表示单链表的头。 2.后面我们每添加一个节点，就直接加入到链表的最后 public class Singl...
线性表的链式存储结构
wangshipeng409的博客
04-24 893
特点：用一组
单链表（Singly LInked LIst)
Sun.ME的博客
02-14 1272
单链表
数据结构——单链表（singly linked list）
weixin_30586257的博客
09-08 270
/* singlyLinkedList.c */ /* 单链表 */ /* 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。 */ #include <stdio.h> #include <stdlib.h> #include <stdbool.h> /* 节点结构 */ /* hea...
C++ 手写链表 最终更新
weixin_45686201的博客
10-12 420
历史更新内容： v1.4.2 更新：添加对尾指针的支持以便PushBack() v1.4.3 更新：添加对前向指针的支持，使之成为双链表以便PopBack() v1.4.4 更新：紧急修复了空表PushFront()和PopFront()时，使用了空指针的（并不存在的）前向指针成员的bug，但代价是各添加了一个if块，会导致性能损失 v1.4.5 更新：添加对循环链表的支持使之成为循环双链表。 老目标： 单链表基本实现 单链表的构造函数 完成Lab2_3 尾指针 双链表 用单链表 (v1.
算法与数据结构笔记11——单链表（Singly Linked List）
裕博的博客
02-11 531
前言 了解数据结构的小伙伴，应该有听说过单链表。那么是单链表呢？单链表的使用是怎么样的呢？下面就分享一下我理解的单链表。 单链表概念 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 单链表示例图 单链...
数据结构与算法（二）单链表（Singly linked list）
花花的博客
01-04 3149
数据结构与算法（二）单链表（Singly linked list）链表（Linked list）Python完整功能实现LeetCode思想实践： 链子这个东西大家一定都不陌生, 脖子上有项链, 自行车上有车链, 手表上有表链… 今天我们要研究的单链表就和他们如出一辙 链表（Linked list） 是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一...
单链表的创建，插入，删除，更新，查询的实现（C语言描述）
qq_43607940的博客
08-04 462
#include<stdio.h> #include<stdlib.h> #define SUCCESS 0; //成功的返回值 #define ERROR -1; //失败的返回值 typedef char ElemType; //结点元素类型 //结点结构体 typedef struct Node { ElemType data; struct Node *next; //指向下一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值