单链表（LinkedList）

最新推荐文章于 2022-11-28 16:36:08 发布
最新推荐文章于 2022-11-28 16:36:08 发布
阅读量1.2k 收藏 8
点赞数 2
分类专栏： 数据结构与算法 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cdreamfly/article/details/105562631
版权

与数组相似，链表也是一种线性数据结构。这里有一个例子：
在这里插入图片描述
  正如你所看到的，链表中的每个元素实际上是一个单独的对象，而所有对象都通过每个元素中的引用字段链接在一起。

  链表有两种类型：单链表和双链表。上面给出的例子是一个单链表，这里有一个双链表的例子：双向链表（DoubleLinkList）在这里插入图片描述
  单链表中的每个结点不仅包含值，还包含链接到下一个结点的引用字段。通过这种方式，单链表将所有结点按顺序组织起来。

下面是一个单链表的例子：
在这里插入图片描述
  蓝色箭头显示单个链接列表中的结点是如何组合在一起的。

结点结构

以下是单链表中结点的典型定义：

template<typename T>
class Node
{
public:
    T e;
    Node<T>*next;
    Node():e(0),next(nullptr){}
    Node(T& E):e(E),next(nullptr){}
    Node(T& E,Node<T>*Next):e(E),next(Next){}
};

  在大多数情况下，我们将使用头结点(第一个结点)来表示整个列表。

操作

  与数组不同，我们无法在常量时间内访问单链表中的随机元素。 如果我们想要获得第 i 个元素，我们必须从头结点逐个遍历。 我们按索引来访问元素平均要花费 O(N) 时间，其中 N 是链表的长度。

  例如，在上面的示例中，头结点是 23。访问第 3 个结点的唯一方法是使用头结点中的“next”字段到达第 2 个结点（结点 6）; 然后使用结点 6 的“next”字段，我们能够访问第 3 个结点。

添加操作 - 单链表

如果我们想在给定的结点 prev 之后添加新值，我们应该：

  1. 使用给定值初始化新结点 cur；
    在这里插入图片描述
  2. 将 cur 的“next”字段链接到 prev 的下一个结点 next；
    在这里插入图片描述
  3. 将 prev 中的“next”字段链接到 cur 。
    在这里插入图片描述

  与数组不同，我们不需要将所有元素移动到插入元素之后。因此，您可以在 O(1) 时间复杂度中将新结点插入到链表中，这非常高效。

示例

在这里插入图片描述
  让我们在第二个结点 6 之后插入一个新的值 9。

  我们将首先初始化一个值为 9 的新结点。然后将结点 9 链接到结点 15。最后，将结点 6 链接到结点 9。

插入之后，我们的链表将如下所示：
在这里插入图片描述

代码：

template<typename T>
void LinkedList<T>::add(int index, T e) {
    if(index >= 0 && index <= size)
    {
        Node<T>*prev = dummyHead;
        for(int i = 0;i<index;++i){
            prev = prev->next;  //遍历到node为要插入节点的前一节点
        }
        //第一种写法
//    Node<T>*newNode = Node<T>(e);   //创建新节点传入直e
//    newNode->next = node->next; //新节点的next指向要插入节点
//    node->next = newNode;   //要插入节点的前一节点的next指向新节点
        //第二种写法
        prev->next = new Node<T>(e,prev->next); //创建一个节点传入直和让新节点的next指向插入节点，然后要插入节点的前一节点的next指向新节点
        ++size;
    }
}

在开头添加结点

  众所周知，我们使用头结点来代表整个列表。

因此，在列表开头添加新节点时更新头结点 head 至关重要。

  1. 初始化一个新结点 cur；
  2. 将新结点链接到我们的原始头结点 head。
  3. 将 cur 指定为 head。

  例如，让我们在列表的开头添加一个新结点 9。

  我们初始化一个新结点 9 并将其链接到当前头结点 23。
在这里插入图片描述
  指定结点 9 为新的头结点。
在这里插入图片描述

代码：

template<typename T>
void LinkedList<T>::addFirst(T e) {
    //第一种写法
//    Node<T>*node = new Node<T>(e);    //创建一个节点，把直放入节点
//    node->next = head;    //让创建的节点的下next指向当前头
//    head = node;  //头指向新创建的节点
    //第二种写法
//    head = new Node<T>(e,head); //新创建一个节点传入数据和头让新节点的next指向head，然后head在指向新节点
//    ++size;
    add(0,e);
}

在末尾添加节点

代码：

template<typename T>
void LinkedList<T>::addLast(int e) {
    add(size,e);
}

删除操作 - 单链表

如果我们想从单链表中删除现有结点 cur，可以分两步完成：

  1. 找到 cur 的上一个结点 prev 及其下一个结点 next；
    在这里插入图片描述
  2. 接下来链接 prev 到 cur 的下一个节点 next。
    在这里插入图片描述

  在我们的第一步中，我们需要找出 prev 和 next。使用 cur 的参考字段很容易找出 next，但是，我们必须从头结点遍历链表，以找出 prev，它的平均时间是 O(N)，其中 N 是链表的长度。因此，删除结点的时间复杂度将是 O(N)。

  空间复杂度为 O(1)，因为我们只需要常量空间来存储指针。

示例在这里插入图片描述

让我们尝试把结点 6从上面的单链表中删除。

  1. 从头遍历链表，直到我们找到前一个结点 prev，即结点 23

  2. 将 prev（结点 23）与 next（结点 15）链接
    在这里插入图片描述
    结点 6 现在不在我们的单链表中。

代码：

template<typename T>
T LinkedList<T>::remove(const int index) {
    if(index>=0 && index<=size)
    {
        Node<T>*prev = dummyHead;
        for(int i = 0;i<index;++i)  //找到要删除节点的前一个节点
        {
            prev = prev->next;
        }
        Node<T>*retNode = prev->next;   //保存要删除的节点
        prev->next = retNode->next; //让前一节点next指向要删除节点的后一节点
        retNode->next = nullptr;    //要删除节点next指向空
        --size;
        return retNode->e;
    }
}

删除第一个结点

如果我们想删除第一个结点，策略会有所不同。

  正如之前所提到的，我们使用头结点 head 来表示链表。我们的头是下面示例中的黑色结点 23。在这里插入图片描述
  如果想要删除第一个结点，我们可以简单地将下一个结点分配给head。也就是说，删除之后我们的头将会是结点 6。
在这里插入图片描述
  链表从头结点开始，因此结点 23 不再在我们的链表中。

代码：

template<typename T>
T LinkedList<T>::removeFirst() {
    return remove(0);
}

删除最后一个结点

代码：

template<typename T>
T LinkedList<T>::removeLast() {
    return remove(size-1);
}

时间复杂度

在这里插入图片描述

代码清单

LinkedList.h

#ifndef C___LINKEDLIST_H
#define C___LINKEDLIST_H
#include <iostream>
template<typename T>
class Node
{
public:
    T e;
    Node<T>*next;
    Node():e(0),next(nullptr){}
    Node(T& E):e(E),next(nullptr){}
    Node(T& E,Node<T>*Next):e(E),next(Next){}
};
template<typename T>
class LinkedList {

public:
    LinkedList();
    //返回连表大小
    int getSize()const;
    //判断是否为空
    bool isEmpty()const;
    //头插入
    void addFirst(T e);
    //为插入
    void addLast(T e);
    //插入
    void add(int index, T e);
    //练习：获取链表第👈index个位置的元素
    T get(const int index);
    //获取链表第一个元素
    T getFirst();
    //获取链表最后一个元素
    T getLast();
    //练习：修改链表第👈index个位置的元素
    void set(const int index,const T&e);
    //查找链表是否有元素e
    bool contains(const T&e)const;
    //删除元素
    T remove(const int index);
    //删除头
    T removeFirst();
    //删除尾
    T removeLast();
    //打印链表
    void print()const;
private:
    Node<T>*dummyHead;  //虚拟头节点，不存数据
    int size;   //记录大小
};

template<typename T>
int LinkedList<T>::getSize() const {
    return size;
}

template<typename T>
bool LinkedList<T>::isEmpty() const {
    return size == 0;
}

template<typename T>
void LinkedList<T>::addFirst(T e) {
    //第一种写法
//    Node<T>*node = new Node<T>(e);    //创建一个节点，把直放入节点
//    node->next = head;    //让创建的节点的下next指向当前头
//    head = node;  //头指向新创建的节点
    //第二种写法
//    head = new Node<T>(e,head); //新创建一个节点传入数据和头让新节点的next指向head，然后head在指向新节点
//    ++size;
    add(0,e);
}

template<typename T>
void LinkedList<T>::add(int index, T e) {
    if(index >= 0 && index <= size)
    {
        Node<T>*prev = dummyHead;
        for(int i = 0;i<index;++i){
            prev = prev->next;  //遍历到node为要插入节点的前一节点
        }
        //第一种写法
//    Node<T>*newNode = Node<T>(e);   //创建新节点传入直e
//    newNode->next = node->next; //新节点的next指向要插入节点
//    node->next = newNode;   //要插入节点的前一节点的next指向新节点
        //第二种写法
        prev->next = new Node<T>(e,prev->next); //创建一个节点传入直和让新节点的next指向插入节点，然后要插入节点的前一节点的next指向新节点
        ++size;
    }
}

template<typename T>
void LinkedList<T>::addLast(T e) {
    add(size,e);
}

template<typename T>
LinkedList<T>::LinkedList() {
    dummyHead = new Node<T>();
    size = 0;
}

template<typename T>
T LinkedList<T>::get(const int index) {
    if(index>=0 && index<=size)
    {
        Node<T>*cur = dummyHead->next;  //把第一个元素的位置给cur
        for(int i = 0;i<index;++i)
        {
            cur = cur->next;
        }
        return cur->e;//返回👈第index个节点的元素
    }
}

template<typename T>
T LinkedList<T>::getFirst() {
    return get(0);
}

template<typename T>
T LinkedList<T>::getLast() {
    return get(size-1);
}

template<typename T>
void LinkedList<T>::set(const int index, const T &e) {
    if(index>=0 && index<=size)
    {
        Node<T> *cur = dummyHead->next;
        for (int i = 0; i < index; ++i) {
            cur = cur->next;
        }
        cur->e = e;
    }
}

template<typename T>
bool LinkedList<T>::contains(const T &e) const {
    //第一种遍历
//    Node<T>*cur = dummyHead->next;
//    while(cur!= nullptr)
//    {
//        if(cur->e == e)
//        {
//            return true;
//        }
//        cur = cur->next;
//    }
//    return false;
    //第二种遍历
    for(Node<T>*cur = dummyHead->next;cur!= nullptr;cur = cur->next)
    {
        if(cur->e == e) //如果找到元素返回true
        {
            return true;
        }
    }
    return false;   //否则返回false
}

template<typename T>
void LinkedList<T>::print() const {
    std::cout << "LinkedList: size = " << size << std::endl;
    std::cout << "[";

    for(Node<T>*cur = dummyHead->next;cur!= nullptr;cur = cur->next)
    {
        std::cout<<cur->e<<"->";
    }
    std::cout<<"NULL"<<"]"<<std::endl;
}

template<typename T>
T LinkedList<T>::remove(const int index) {
    if(index>=0 && index<=size)
    {
        Node<T>*prev = dummyHead;
        for(int i = 0;i<index;++i)  //找到要删除节点的前一个节点
        {
            prev = prev->next;
        }
        Node<T>*retNode = prev->next;   //保存要删除的节点
        prev->next = retNode->next; //让前一节点next指向要删除节点的后一节点
        retNode->next = nullptr;    //要删除节点next指向空
        --size;
        return retNode->e;
    }
}

template<typename T>
T LinkedList<T>::removeLast() {
    return remove(size-1);
}

template<typename T>
T LinkedList<T>::removeFirst() {
    return remove(0);
}
#endif

main.cpp

int main()
{

    LinkedList<int> *ll;
    ll = new LinkedList<int>();
    for(int i = 0;i<10;++i)
    {
        ll->addFirst(i);
        ll->print();
    }
    ll->add(2,666);
    ll->print();
    cout<<endl;
    cout<<"get(2)"<<ll->get(2)<<endl;
    cout<<"getSize()"<<ll->getSize()<<endl;
    cout<<"getFirst()"<<ll->getFirst()<<endl;
    cout<<"getLast()"<<ll->getLast()<<endl;
    cout<<"isEmpty"<<ll->isEmpty()<<endl;
    cout<<"contains"<<ll->contains(666)<<endl;
    ll->set(3,999);
    ll->addLast(000);
    ll->print();
    cout<<endl;
    ll->removeLast();
    ll->removeFirst();
    ll->remove(1);
    ll->print();
    return 0;
}
吃米饭
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
基于C语言的数据结构-单链表linkedList
06-25
基于C语言的数据结构-单链表linkedList
Java集合：LinkedList解析与使用
h_xhbxh的博客
02-10 743
目录 1.概念解析 2.基本使用 3.源码解读 1.概念解析 （1）基本概念：链表（LinkedList）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用。 （2）基本特征： ① 数据是按照插入有序。 ② 数据是可以重复插入的。 ③ 集合是可以存储null的。 ④ 底层采用的数据结构是双向链表。 ⑤ 可以被当作堆栈、队列或双端队列进行操作。
linkedlist
palawind
09-24 133
using System; using System.Collections.Generic; namespace ConsoleApplication {     class Program     {         static void Main(string[] args)         {             LinkedList&lt;int&gt; a = new Link...
java linkedlist int_Java集合之LinkedList
weixin_39639568的博客
02-26 125
Deque定义C++：dequeJava：LinkedList创建与其基本操作创建：LinkedList qmax=new LinkedList();基本操作：void clear( )int peekFirst();int peekLast();int pollFirst();int pollLast();int addFirst(Object o);int addLast(Object o);...
java linkedlist int_Java集合类 之 LinkedList
weixin_42301413的博客
02-26 394
一、 LinkedList3.1创建：LinkedList()LinkedList底层的数据结构是一个双向链表。既然是双向链表，那么必定存在一种数据结构——我们可以称之为节点，节点实例保存业务数据，前一个节点的位置信息和后一个节点位置信息，如下图所示：图——双线链表及节点示意图首先来了解节点类：private static class Entry{E element;Entry nex...
链表剖析及自己手撸“单链表“实现基本操作(初始化、增、删、改等)
a410974689的博客
11-28 396
存储数据元素时，除了存储数据元素本身的信息外，还有一个指针，指向他的后继节点，最后一个元素的指针不指向任何元素。：在单链表的基础上加一个前驱指针，指向前一个元素，是链表可以双向查找，这种结构成为双链表。：将链表最后一个节点的指针指向第一个节点，这样就形成了一个环，这种数据结构叫做单向循环列表.另外还有双向循环列表.
我的学习笔记（一）：LinkedList在c++中的实现
wechat28的博客
09-13 2575
今天是中秋节，开学第三周周末了，这学期让我感觉最有趣的课是python和数据结构，数据结构的前几节课，老师讲了list链表的两种实现方式，分别是Arraybased List和LinkedList。我感觉了解数据结构的底层实现方式特别有趣，于是课下自己花了两天的课余时间尝试了LinkedList的实现，在这里分享一下自己的心得。 一. 简介 List, 是一个由多个结点连接而成的链表，像一个火车一...
C++使用模板实现单链表
12-31
本文实例为大家分享了用模板实现单链表，供大家参考，具体内容如下 话不多说 直接上代码 #include using namespace std; template class CLink; template class Node { friend class CLink; public: /* 构造...
LinkedList.java
10-17
数据结构始终是计算机科学绕不开的话题，是计算机中存储、组织数据的方式。学习数据结构能让我们明白，如何更高效的存、取数据。编写程序的目的就是为了处理...本资源是博主利用单链表实现了LinkedList的基本核心功能。
List-LinkedList 单链表就地反转
05-09
List-LinkedList 单链表就地反转 的代码的一种实现。
linkedList:java单链表的实现和简单操作
06-23
linkedListjava单链表的实现和简单操作注意isCircle()这个函数是判断单链表是否成环的函数，由于是单链表所以头尾指针只有一个，所以出现环只能是大圈，最后一个和头结点成环，不可能出现中间“打结”的情况，我们...
LinkedList详解
藏起来的心跳
07-28 1338
参考文章：https://blog.csdn.net/qedgbmwyz/article/details/80108618 一、源码解析1、 LinkedList类定义2、LinkedList数据结构原理3、私有属性4、构造方法5、元素添加add()及原理6、删除数据remove()7、数据获取get()8、数据复制clone()与toArray()9、遍历数据：Iterator()二、ListItr 一、源码解析 1、LinkedList类定义。 public class...
Android 文件读写
jven的博客
07-25 205
读取 /** * 文件读取 * @param is 文件的输入流 * @return 返回文件数组 */ private byte[] read(InputStream is) { //缓冲区inputStream BufferedInputStream bis = null; //用于存储数据 ByteArrayOutputStream baos = null; try { //每次读1024 byte[] b = new byte[1024];
[C#复习向整合]LinkedList
VAherggoooooo的博客
07-29 560
本质:可变类型的泛型双向链表 声明 需要命名空间System.Collections.Generic LinkedList<int> _list = new LinkedList<int>(); 增 _list.AddLast(10);//往链表尾部添加10 _list.AddFirst(20);//往表头添加20 删 _list.RemoveFirst();//移除头节点 _list.RemoveLast();//移除尾节点 _list.Remove(
对链表结构体定义中的LNode,*LinkList的理解
热门推荐
haishi1024的博客
03-28 1万+
目录 1.定义单链表存储结构 2.创建单链表 3.图解LNode与*LinkList的联系​ 1.定义单链表存储结构 typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; 以上代码段可以分解为： typedef struct LNode LNode; //将结构体类型struct LNode重命名为LNode typedef struct LNode ...
链表(Linked List)----单链表
weixin_51599093的博客
10-24 680
链表
c语言 单链表 面向对象构造,C语言/C++编程学习—数据结构—单链表
weixin_42131352的博客
05-24 142
C语言是面向过程的，而C＋＋是面向对象的C和C++的区别：C是一个结构化语言，它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程，对输入(或环境条件)进行运算处理得到输出(或实现过程(事务)控制)。C++，首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出或实现过程(事务)控制。 所以C与C++的最大区别在于它们的用于解...
链表（LinkList）---单链表
Cxf2018的博客
03-18 636
一、链表的基本概念 链表是一种物理上不连续、非顺序的存储结构，数据元素之间通过指针关联在一起。 链表有一系列的节点构成，每个节点至少包含两部分信息：元素数据、指向下一个节点的指针。 链表的特点： 1）空间开销大（物理空间不连续） 2）可以动态添加新的节点 3）查找元素只能按顺序查找 二、单向链表 图示 节点代码 class Node{//节点 public: in...
python 双向链表_面试官：LinkedList是单向链表还是双向链表？
weixin_39947908的博客
11-26 404
面试官：你能说说 LinedList 吗？Python 小星：LinedList 数据结构是链表，查询慢，增删快。面试官：那 LinkedList 是单向链表还是双向链表？Python 小星：双向链表面试官：那 LinkedList 是双向循环链表吗？Python 小星：......面试官：没事，那我问你 LinkedList 为什么不用单链表，而是用双链表？Python 小星：......面试官...
linkedlist.removelast()详解
最新发布
05-29
linkedlist.removelast() 是一个 LinkedList 类中的方法，用于从链表的末尾移除最后一个元素，并返回被移除的元素。 具体实现过程如下： 1. 检查当前链表是否为空，如果为空，则抛出 NoSuchElementException。 2. 如果链表不为空，则先将链表的 tail 节点保存到一个临时变量中。 3. 检查链表的 size 是否为 1，如果是，则将 head 和 tail 节点都置为 null，同时将 size 设为 0。 4. 如果链表的 size 不为 1，则需要找到最后一个节点的前一个节点，即倒数第二个节点，将其 next 指向 null，同时将 tail 节点置为倒数第二个节点。 5. 返回被移除的节点的元素值。 下面是一个 Java 实现示例： ``` public E removeLast() { if (size == 0) { throw new NoSuchElementException(); } Node<E> temp = tail; if (size == 1) { head = tail = null; } else { Node<E> current = head; for (int i = 0; i < size - 2; i++) { current = current.next; } tail = current; tail.next = null; } size--; return temp.element; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

吃米饭

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值