一问读懂链表结构，及应用场景

最新推荐文章于 2024-03-06 20:14:14 发布
最新推荐文章于 2024-03-06 20:14:14 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： Java高级 算法 文章标签： 链表 数据结构 java
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/u012581020/article/details/130771937
版权

Java中的链表结构是指，将一组数据按照指定规则连接起来的数据结构。它由多个节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用。在Java中，这种数据结构被封装成了一个链表类，常见的有单向链表、双向链表和循环链表等。

一、单向链表

单向链表是最简单的一种链表结构，节点只包含一个数据元素和一个指向下一个节点的引用。它的优点是删除和插入节点非常方便，但是定位元素较为困难。

  1. 链表的节点定义

    public class Node {
    // 节点的数据元素
    private int data;
    // 指向下一个节点的引用
    private Node next;

    // 构造函数
    public Node(int data) {
        this.data = data;
        this.next = null;
    }

    // 获得数据元素
    public int getData() {
        return data;
    }

    // 设置数据元素
    public void setData(int data) {
        this.data = data;
    }

    // 获得下一个节点的引用
    public Node getNext() {
        return next;
    }

    // 设置下一个节点的引用
    public void setNext(Node next) {
        this.next = next;
    }
}

  2. 链表的操作方法

    • 添加节点：向链表的末尾添加一个新节点

      public void addNode(int data) {
    Node newNode = new Node(data);
    if (head == null) {
        head = newNode;
    } else {
        Node currentNode = head;
        while (currentNode.getNext() != null) {
            currentNode = currentNode.getNext();
        }
        currentNode.setNext(newNode);
    }
    size++;
}

    • 删除节点：删除链表中指定元素的节点

      public boolean removeNode(int data) {
    if (head == null) {
        return false;
    }
    if (head.getData() == data) {
        head = head.getNext();
        size--;
        return true;
    }
    Node currentNode = head;
    while (currentNode.getNext() != null) {
        if (currentNode.getNext().getData() == data) {
            currentNode.setNext(currentNode.getNext().getNext());
            size--;
            return true;
        }
        currentNode = currentNode.getNext();
    }
    return false;
}

    • 查找节点：根据元素值查找节点

      public Node findNode(int data) {
    if (head == null) {
        return null;
    }
    Node currentNode = head;
    while (currentNode != null) {
        if (currentNode.getData() == data) {
            return currentNode;
        }
        currentNode = currentNode.getNext();
    }
    return null;
}

二、双向链表

双向链表是在单向链表基础上增加了一个指向前一个节点的引用，这样可以方便地实现反向遍历和插入、删除操作。但是相应地，它需要占用更多的存储空间。

  1. 链表的节点定义

    public class Node {
    // 节点的数据元素
    private int data;
    // 指向下一个节点的引用
    private Node next;
    // 指向前一个节点的引用
    private Node prev;

    // 构造函数
    public Node(int data) {
        this.data = data;
        this.next = null;
        this.prev = null;
    }

    // 获得数据元素
    public int getData() {
        return data;
    }

    // 设置数据元素
    public void setData(int data) {
        this.data = data;
    }

    // 获得下一个节点的引用
    public Node getNext() {
        return next;
    }

    // 设置下一个节点的引用
    public void setNext(Node next) {
        this.next = next;
    }

    // 获得前一个节点的引用
    public Node getPrev() {
        return prev;
    }

    // 设置前一个节点的引用
    public void setPrev(Node prev) {
        this.prev = prev;
    }
}

  2. 链表的操作方法

    • 添加节点：向链表的末尾添加一个新节点

      public void addNode(int data) {
    Node newNode = new Node(data);
    if (head == null) {
        head = newNode;
    } else {
        Node currentNode = head;
        while (currentNode.getNext() != null) {
            currentNode = currentNode.getNext();
        }
        currentNode.setNext(newNode);
        newNode.setPrev(currentNode);
    }
    size++;
}

    • 删除节点：删除链表中指定元素的节点

      public boolean removeNode(int data) {
    if (head == null) {
        return false;
    }
    if (head.getData() == data) {
        head = head.getNext();
        if (head != null) {
            head.setPrev(null);
        }
        size--;
        return true;
    }
    Node currentNode = head;
    while (currentNode != null) {
        if (currentNode.getData() == data) {
            currentNode.getPrev().setNext(currentNode.getNext());
            if (currentNode.getNext() != null) {
                currentNode.getNext().setPrev(currentNode.getPrev());
            }
            size--;
            return true;
        }
        currentNode = currentNode.getNext();
    }
    return false;
}

    • 查找节点：根据元素值查找节点

      public Node findNode(int data) {
    if (head == null) {
        return null;
    }
    Node currentNode = head;
    while (currentNode != null) {
        if (currentNode.getData() == data) {
            return currentNode;
        }
        currentNode = currentNode.getNext();
    }
    return null;
}

三、循环链表

循环链表是一种特殊的链表结构，它的最后一个节点的指针不是指向null，而是指向第一个节点，形成一个环状结构。这样在循环遍历时可以省去边界判断，但是插入和删除操作需要特殊考虑。

  1. 链表的节点定义

    public class Node {
    // 节点的数据元素
    private int data;
    // 指向下一个节点的引用
    private Node next;

    // 构造函数
    public Node(int data) {
        this.data = data;
        this.next = null;
    }

    // 获得数据元素
    public int getData() {
        return data;
    }

    // 设置数据元素
    public void setData(int data) {
        this.data = data;
    }

    // 获得下一个节点的引用
    public Node getNext() {
        return next;
    }

    // 设置下一个节点的引用
    public void setNext(Node next) {
        this.next = next;
    }
}

  2. 链表的操作方法

    • 添加节点：向链表的末尾添加一个新节点

      public void addNode(int data) {
    Node newNode = new Node(data);
    if (head == null) {
        head = newNode;
        head.setNext(head);
    } else {
        Node currentNode = head;
        while (currentNode.getNext() != head) {
            currentNode = currentNode.getNext();
        }
        currentNode.setNext(newNode);
        newNode.setNext(head);
    }
    size++;
}

    • 删除节点：删除链表中指定元素的节点

      public boolean removeNode(int data) {
    if (head == null) {
        return false;
    }
    if (head.getData() == data) {
        Node currentNode = head;
        while (currentNode.getNext() != head) {
            currentNode = currentNode.getNext();
        }
        head = head.getNext();
        currentNode.setNext(head);
        size--;
        return true;
    }
    Node currentNode = head;
    while (currentNode.getNext() != head) {
        if (currentNode.getNext().getData() == data) {
            currentNode.setNext(currentNode.getNext().getNext());
            size--;
            return true;
        }
        currentNode = currentNode.getNext();
    }
    return false;
}

    • 查找节点：根据元素值查找节点

      public Node findNode(int data) {
    if (head == null) {
        return null;
    }
    Node currentNode = head;
    while (currentNode.getNext() != head) {
        if (currentNode.getData() == data) {
            return currentNode;
        }
        currentNode = currentNode.getNext();
    }
    if (currentNode.getData() == data) {
        return currentNode;
    }
    return null;
}

四、链表的时间复杂度分析

链表结构相比于数组具有更灵活的插入和删除操作，但是它也存在一些缺点。在访问随机元素时，需要从头开始遍历整个链表，时间复杂度为O(N)；而在数组中可以通过索引直接访问元素，时间复杂度为O(1)。下面给出单向链表、双向链表和循环链表的常见操作的时间复杂度：

操作单向链表双向链表循环链表
访问元素O(N)O(N)O(N)
插入元素O(1)O(1)O(1)
删除元素O(N)O(N)O(N)

五、链表的应用举例

链表结构常见于计算机科学领域中的各种数据结构与算法，例如栈、队列、哈希表和图等。下面以一个简单的应用场景为例，说明链表的应用。

  1. 题目描述

    给定一个链表，判断它是否为回文链表。回文链表是指正序和倒序读取的结果相同的链表。

  2. 解题思路

    可以使用快慢指针将链表分成两半，然后将后半部分反转，最后比较前半部分和反转后的后半部分是否相同。

  3. 代码实现

    public boolean isPalindrome(Node head) {
    if (head == null || head.getNext() == null) {
        return true;
    }
    Node slow = head, fast = head;
    while (fast.getNext() != null && fast.getNext().getNext() != null) {
        slow = slow.getNext();
        fast = fast.getNext().getNext();
    }
    Node secondHalf = reverseList(slow.getNext());
    Node currentNode = head;
    while (secondHalf != null) {
        if (currentNode.getData() != secondHalf.getData()) {
            return false;
        }
        currentNode = currentNode.getNext();
        secondHalf = secondHalf.getNext();
    }
    return true;
}

private Node reverseList(Node head) {
    if (head == null || head.getNext() == null) {
        return head;
    }
    Node prev = null, current = head;
    while (current != null) {
        Node next = current.getNext();
        current.setNext(prev);
        prev = current;
        current = next;
    }
    return prev;
}

六、使用场景

使用场景，常见的应用包括：

  1. 实现栈和队列：链表作为栈或队列的底层数据结构，实现入栈、出栈、入队、出队等操作时具有高效性和灵活性。
  2. 实现哈希表：在哈希表中，每个关键字会被映射到一个桶中，而这个桶则是一个链表，其中存放相同关键字的元素。
  3. 作为缓存的数据结构：在缓存中，经常需要在数据集中插入、删除、移动元素。链表结构提供了一种高效的方式来操作这些数据。
  4. 浏览器历史记录和撤销功能：浏览器历史记录和撤销功能等需要保留一系列操作或状态的应用场景都可以使用链表来实现。
  5. 实现图论算法：在图论中，使用链表结构可以方便地表示邻接表，保存每个节点的所有邻居节点。
  6. 数据库管理系统：在数据库管理系统中，可以使用链表来优化查询操作的效率。
大家都说我身材好
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
三、单向链表和双向链表
AsiaLYF
11-07 501
单向链表和双向链表的介绍
链表的概念、使用场景、常见链表
qq_43334139的博客
03-01 1460
回答了什么是链表，为什么使用链表，以及常用的链表及其使用场景
Java 与数据结构（2）：链表
暗星涌动
05-15 902
链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。链表中的第一个节点称为头节点，最后一个节点称为尾节点，尾节点的指针指向 NULL。相比于数组，链表的优点是可以动态地分配内存，不需要预先知道存储元素的个数，而且插入和删除操作的时间复杂度为 O(1)。链表常见的类型有单向链表、双向链表和循环链表。单向链表每个节点只包含一个指向下一个节点的指针，而双向链表每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点。循环链表的尾节点的指针指向头节点，形成一个环。
【数据结构】链表的原理及java实现
热门推荐
简约人生的博客
04-20 11万+
一：单向链表基本介绍链表是一种数据结构，和数组同级。比如，Java中我们使用的ArrayList，其实现原理是数组。而LinkedList的实现原理就是链表了。链表在进行循环遍历时效率不高，但是插入和删除时优势明显。下面对单向链表做一个介绍。单向链表是一种线性表，实际上是由节点（Node）组成的，一个链表拥有不定数量的节点。其数据在内存中存储是不连续的，它存储的数据分散在内存中，每个结点只能也只有它
单链表应用实例
jefferyfg的博客
09-25 2584
在学习单链表之前，先简单了解一下链表 链表是有序的链表，但它在内存中是存储如下 链表是以节点的方式来存储的，是链式存储 每个节点包含data域、next域：指向下一个节点 链表的各个节点不一定是连续存储 链表分带头节点的链表和没有头结点的列表，根据实际需求来定 单链表（带头结点）逻辑结构示意图如下： 单链表的应用实例： 使用带head头节点的单向链表实现水浒英雄人物的增删改查操作 ， 1....
Java数据结构篇之链表
MasterJundarj的博客
09-23 2427
/头插法//尾插法//任意位置插入,第一个数据节点为0号下标//查找是否包含关键字key是否在单链表当中//删除第一次出现关键字为key的节点//删除所有值为key的节点//得到单链表的长度int size();@Override@Override【解释】
数据结构链表的应用C++一元多项式求和
03-04
数据结构，链表的应用，基于C++，一元多项式求和，带主程序，可直接运行。
数据结构实验 一元多项式运算 链表应用
07-18
C/C++实现一元多项式，包括源代码和实验报告。实现了一元多项式的创建，查看，相加和相乘。
数据结构学习--线性表及其应用--链表
06-25
本程序的主要目的在于帮助同学熟练掌握线性表的基本操作在链式存储结构上的...通过本实验， 对链表基本操作及其组合应用的演练，加深对链表存储方法及其基本操作的理解，为以后进 一步学习更复杂的数据结构打下基础。
设计一个基于链表的数据结构
11-18
课题：设计一个基于链表的数据结构，实现一个简单的学生信息管理系统。 1. 确定课程目标和内容：本课题的目标是让学生掌握链表数据结构的基本原理和应用，培养学生的编程能力和逻辑思维能力。课程内容包括链表的...
链表的应用
09-10
里面含有链表的例题和源代码及运行截屏，希望对于想提高自己链表能力，更加透彻的理解，灵活运用链表的学习者有帮助
利用双向循环链表解决面试问题
11-03
某公司在对应聘者做过一轮笔试之后，从中选出n人继续进行面试，每位应聘者按照到达顺序，ID被分配为1~n。 为公平起见，组织者决定利用会议室外的圆桌，按以下方法“随机”确定面试顺序：第一个到达的应聘者在圆桌周围任意选择一个位置坐下；此后到达的每位应聘者都从前一应聘者出发，沿逆时针方向围圆桌走过m人（前一应聘者算作走过的第1人，同一人可能经过多次），并紧邻第m人右侧就座；所有应聘者到齐后，从最后到达者出发，绕圆桌以顺时针方向为序进行面试。 这里假定应聘者到达的时刻互异，且相对的就坐位置确定后，左、右两人之间总能插入一把椅子。试编写一个程序，确定面试顺序。
Redis数据类型及应用场景
01-07
1、Redis 是一种键值（Key-Value...3、其中跳表为插入，删除，查询比较快的动态数据结构，跳表是一个值有序的链表建立多级索引，比如每2个节点提取一个节点到上一级，我们把抽出来的那一级叫做索引或索引层； 4、为什么
数据结构--链表实际场景应用
BtWangZhi的博客
04-28 1505
时间应用场景，构造一个固定长度的列表，达到固定长度后，自动淘汰尾部的节点 /** * 固定大小的容器，当添加的个数达到上限时， * 自动淘汰添加时间最长的元素 * * @param <E> */ private static class FixElementList<E> { /** * 头指针 */ private Node<E> he
单链表和双向链表的区别与使用场景
mlyhzt的博客
10-20 2465
单向链表：只有一个指向下一个节点的指针。 优点：单向链表增加删除节点简单。遍历时候不会死循环； 缺点：只能从头到尾遍历。只能找到后继，无法找到前驱，也就是只能前进。 适用于节点的增加删除。   双向链表：有两个指针，一个指向前一个节点，一个后一个节点。 优点：可以找到前驱和后继，可进可退； 缺点：增加删除节点复杂，需要多分配一个指针存储空间。 适用于需要双向查找节点值的情况。 ...
Java版的数据结构——链表
ANNE_fly的博客
09-12 628
LinkedList的官方文档LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。【说明】实现了List接口2. LinkedList的底层使用了双向链表3. LinkedList没有实现RandomAccess（该接口是实现随机访问）接口，因此LinkedList不支持随机访问。
【数据结构与算法】深入浅出：单链表的实现和应用
青竹雾色间.的博客
06-07 5012
在本篇博客中，我们将深入探索一种常见的数据结构——单链表。
Java初级数据结构链表的实现(单向链表)（工程文件后续会上传至博客）
最新发布
cjmyydsds的博客
03-06 916
1.2链表的引出（1）为了解决顺序表插入和删除的麻烦，可以让我们随意插入删除，不挪动元素呢？（2）这时候就产生了链表这个数据结构来对这个问题进行解决（3）链表可以理解为一个火车。（4）链表是由节点组成的，每个节点都有几个相对应的地址，每一个节点都由两个域组成，数值域VAL和next区域（数值域就是用来存数据）(8)是链表的第一个节点，它是用来存指向下一个的next域的地址的。(位置是不会进行变化的）1.2.2链表的分类带头的节点，头节点标志的是永远是一个头不会变。
Java-数据结构-链表＜一＞
weixin_45532984的博客
07-01 921
链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）[1]，通常链表的头被称为head，尾部一般用null表示。...............
单向链表和双向链表的应用场景
09-21
双向链表适用于需要频繁在链表的任意位置插入和删除节点，或者需要在双向遍历的情况下快速访问前一个节点的场景。双向链表相较于单向链表，多了一个指向前一个节点的引用，这样可以方便地实现反向遍历和插入、删除...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

大家都说我身材好

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

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

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

打赏作者

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

抵扣说明：

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

余额充值