【数据结构】单链表 双向链表

已于 2024-10-10 22:37:24 修改
阅读量3.4k 收藏 174
点赞数 240
分类专栏： 数据结构 文章标签： 数据结构 java 链表
于 2024-07-11 15:29:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yj20040627/article/details/140300884
版权

目录


转场

一、链表

链表就是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。
也是线性表。
数据域：存储数据元素信息的域。
指针域：存储直接后继的信息。

链表

二、链表的分类

链表根据三个条件分类：

  1. 有头无头：有没有头结点，头结点的数据域是无用的。
  2. 是否循环：尾结点又指回头。
  3. 单向还是双向：指针域包不包含指向前面域的指针。

根据以上3个条件来分类（每一个条件选一），链表一共有8种。

三、单链表

单链表全称为：无头单向不循环链表。

3.1 单链表接口的实现

自己实现一个单链表（存储int数据类型），将单链表作为一个类，我们实现一些“接口”即成员方法来实现数据的增删查改。

// 1、无头单向非循环链表实现
 public class SingleLinkedList {

     //头插法
     public void addFirst(int data);
     //尾插法
     public void addLast(int data);
     //任意位置插入,第一个数据节点为0号下标
     public boolean addIndex(int index,int data);
     //查找是否包含关键字key是否在单链表当中
     public boolean contains(int key);
     //删除第一次出现关键字为key的节点
     public void remove(int key);
     //删除所有值为key的节点
     public void removeAllKey(int key);
     //得到单链表的长度
     public int size();
     //清空链表
     public void clear();
 }

3.2 内部类

因为我们需要使用数据域，指针域，在链表中一个一个串起来。那我们就将数据域指针域使用一个静态内部类来封装。只将第一个节点用head来表示。

注意：此处的head不是链表分类时的头，因为分类的头的数据域的数据是无效的而此处是有效的。

public class SingleLinkedList {


   static class ListNode{
        public int val;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }

    public ListNode head;
}

3.3 头插法

实现思路：
将当前节点的下一个节点（next）指向头（head），再改头为当前节点。

public void addFirst(int data) {
        ListNode cur = new ListNode(data);
        cur.next = head;
        head = cur;
    }

3.4 尾插法

实现思路：

  1. 先判断链表是否为空，为空头指向尾插节点（因为尾插涉及尾结点的next，链表如果为空就会空指针异常）。
  2. 链表不为空，使用循环找到尾结点，next指向尾插节点。
public void addLast(int data){
        if(head == null){
            head = new ListNode(data);
            return;
        }
        ListNode cur = head;
        while(cur.next != null){
            cur = cur.next;
        }
        cur.next = new ListNode(data);
    }

3.5 任意位置插入

实现思路：

  1. 先判断插入位置合法吗，不合法就抛异常。
  2. 头尾位置插入调用头插尾插函数即可。
  3. 中间节点插入找到前一个位置记录下来，当前位置记录下来， 在改插入节点和前一个节点的next。
public boolean addIndex(int index,int data) throws IndexIllegalException{
        try{
            if(index < 0 || index > size()){
                throw new IndexIllegalException("位置不合法");
            } else if (index == 0) {
                addFirst(data);
                return true;
            } else if (index == size()) {
                addLast(data);
                return true;
            }else{
                ListNode cur = head;
                ListNode pre = head;
                ListNode newNode = new ListNode(data);

                for (int i = 0; i < index-1; i++) {
                    cur = cur.next;
                    pre = pre.next;
                }
                newNode.next = cur.next;
                pre.next = cur;
                return true;
            }
        }catch(IndexIllegalException e){
            e.printStackTrace();
            return false;
        }
    }

3.6 查找是否包含关键字key是否在单链表当中

使用循环遍历即可。

public boolean contains(int key){
        ListNode cur = head;
        for (int i = 0; i < size(); i++) {
            if(cur.val == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

3.7 删除第一次出现关键字为key的节点

实现思路：

  1. 看链表是否为空，空直接返回。
  2. 先看头结点是不是要删的节点（因为删除会涉及被删节点的前一个节点），是直接将头指向下一个节点。
  3. 循环找到当前节点，让前一个节点next指向当前节点的next即可。
public void remove(int key){
        if(head == null){
            return;
        } else if (head .val == key) {
            head = head.next;
            return;
        }
        ListNode cur = head.next;
        ListNode pre = head;

        while(cur != null){
            if(cur.val == key){
                pre.next = cur.next;
                return;
            }
            cur = cur.next;
            pre = pre.next;
        }
    }

3.8 删除所有值为key的节点

跟删除一个节点一个逻辑只不过删除后不返回，并且头结点最后判断。

 public void removeAllKey(int key){
        if(head == null){
            return;
        }
        ListNode cur = head.next;
        ListNode pre = head;

        while(cur != null){
            if(cur.val == key){
                pre.next = cur.next;
                cur = cur.next;

            }else {
                cur = cur.next;
                pre = pre.next;
            }
        }
        if(head.val == key){
            head = head.next;
        }
    }

3.9 得到单链表的长度

直接循环遍历就行。

public int size(){
        ListNode cur = head;
        int size = 0;
        while(cur != null){
            cur = cur.next;
            size++;
        }
        return size;
    }

3.10 清空链表

直接循环将每一个节点置空，注意置空前要将头先向后走。

public void clear(){
        ListNode cur = head;
        while (cur != null){
            head = cur.next;
            cur = null;
            cur = head;
        }
    }

3.11 单链表的优缺点

优缺点如下：

  • 优点：单向链表增加删除节点简单。
  • 缺点：只能从头到尾遍历，只能找到后继。

四、双向链表

在Java的集合类中使用的是无头双向非循环链表。
双向链表

4.1 双向链表接口的实现

自己实现一个双向链表（存储int数据类型），将双向链表作为一个类，我们实现一些“接口”即成员方法来实现数据的增删查改。

 // 2、无头双向链表实现
 public class LinkedList {
     //头插法
     public void addFirst(int data);
     //尾插法
     public void addLast(int data);
     //任意位置插入,第一个数据节点为0号下标
     public boolean addIndex(int index,int data);
     //查找是否包含关键字key是否在单链表当中
     public boolean contains(int key);
     //删除第一次出现关键字为key的节点
     public void remove(int key);
     //删除所有值为key的节点
     public void removeAllKey(int key);
     //得到链表的长度
     public int size();
     //情空链表
     public void clear();
 }

4.2 内部类

因为我们需要使用数据域，指针域，在链表中一个一个串起来。那我们就将数据域指针域使用一个静态内部类来封装。只将第一个节点用head来表示，最后一个节点用last表示。

注意：此处的head不是链表分类时的头，因为分类的头的数据域的数据是无效的而此处是有效的。

static class ListNode{
        public int val;
        public ListNode prev;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }
    public ListNode head;
    public ListNode last;

4.3 头插法

实现思路：

  1. 如果当前链表为空就直接将头尾指向当前节点。
  2. 如果不是先将插入节点的下一个指向头，头的前一个指向插入节点，头指向插入节点。
    public void addFirst(int data){
        ListNode cur = new ListNode(data);
        if(head == null){
            head = last = cur;
            return;
        }
        cur.next = head;
        head.prev = cur;
        head = cur;
    }

4.4 尾插法

实现思路：

  1. 看链表是否为空，为空直接头和尾指向插入节点。
  2. 链表不为空，将尾结点的next指向插入节点，将插入节点的prev指向尾结点，将尾结点改为插入节点。
public void addLast(int data){
        ListNode cur = new ListNode(data);
        if(last == null){
            head = last = cur;
            return;
        }
        last.next = cur;
        cur.prev = last;
        last = cur;
    }

4.5 任意位置插入

实现思路：

  1. 判断位置是否合法，不合法抛异常。
  2. 插入位置为头尾，对应调用头插方法，尾插方法。
  3. 找到插入位置对应节点，将插入节点前驱prev改为对应节点前驱，对应节点前驱改为插入节点，插入节点后继next改为对应节点。
public boolean addIndex(int index,int data) throws IndexIllegalException{
        try{
            if(index < 0 || index > size()){
                throw new IndexIllegalException("插入位置不合法");
            } else if (index == 0) {
                addFirst(data);
                return true;
            } else if (index == size()) {
                addLast(data);
                return true;
            }else {
                ListNode cur = head;
                ListNode newNode = new ListNode(data);
                for (int i = 0; i < index; i++) {
                    cur = cur.next;
                }
                newNode.prev = cur.prev;
                cur.prev = newNode;
                newNode.next = cur;
                return true;
            }

        }catch (IndexIllegalException e){
            e.printStackTrace();
            return false;
        }
    }

4.6 查找是否包含关键字key是否在单链表当中

直接循环遍历就行。

public boolean contains(int key){
        ListNode cur = head;
        while(cur != null){
            if(cur.val == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

4.7 删除第一次出现关键字为key的节点

实现思路：

  1. 先判断头节点是不是要删的节点，是将下一个节点前驱prev置为空，头指向下一个节点，返回。
  2. 循环遍历除头尾节点外的节点，找到被删节点，将该节点前一个节点的后继next改为该节点的下一个节点，该节点后一个节点的前驱prev改为该节点的前一个，返回。
  3. 如果都不是，判断尾节点，将尾结点的前一个节点的后继next置为空，尾结点改为前一个节点，返回。
public void remove(int key){
        ListNode cur = head;
        if(head.val == key){
            head.next.prev = null;
            head = head.next;
            return;
        } else {
            while(cur.next != null){
                if(cur.val == key){
                    cur.prev.next = cur.next;
                    cur.next.prev = cur.prev;
                    return;
                }
                cur = cur.next;
            }
            if (last.val == key) {
                last.prev.next = null;
                last = last.prev;
                return;
            }
        }
    }

4.8 删除所有值为key的节点

  1. 先循环遍历除头尾节点外的节点，找到被删节点，将该节点前一个节点的后继next改为该节点的下一个节点，该节点后一个节点的前驱prev改为该节点的前一个。
  2. 判断头节点是不是要删的节点，是将下一个节点前驱prev置为空，头指向下一个节点。
  3. 判断尾节点，将尾结点的前一个节点的后继next置为空，尾结点改为前一个节点。
public void removeAllKey(int key){
        ListNode cur = head.next;
        while(cur.next != null){
            if(cur.val == key){
                cur.prev.next = cur.next;
                cur.next.prev = cur.prev;
            }
            cur = cur.next;
        }
        if(head.val == key){
            head.next.prev = null;
            head = head.next;
        }
        if (last.val == key) {
            last.prev.next = null;
            last = last.prev;
        }
    }

4.9 得到链表的长度

直接循环遍历即可。

public int size(){
        ListNode cur = head;
        int size = 0;
        while(cur != null){
            size++;
            cur = cur.next;
        }
        return size;
    }

4.10 清空链表

实现思路：

  1. 先循环遍历将每一个节点前驱prev后继next置为空。
  2. 最后将头head和为last置为空。
public void clear(){
        ListNode cur = head;
        while(cur != null){
            ListNode curNext = cur.next;
            cur.prev = null;
            cur.next = null;
            cur = curNext;
        }
        head = null;
        last = null;
    }
}

五、Java中的LinkedList

在Java中用集合类LinkedList来表示双向链表。

5.1 实现的接口

接口

接口说明：

  • 没有实现RandomAccess接口，不能随机访问。
  • 实现了Cloneable接口，可克隆。
  • Serializable接口表示支持序列化。

5.2 构造方法

Java中提供了两个构造方法。

方法方法用途介绍
LinkedList()无参构造
public LinkedList(Collection<? extends E> c)使用其他集合容器中元素构造List

5.3 常用方法

提供的常用方法与上面实现的差不多。
在这里插入 图片描述

5.4 双向链表的优劣

优缺点如下：

  • 优点：可以找到前驱和后继，可进可退。
  • 确点：删除节点复杂，需要多分配一个指针域。

六、ArrayList和LinkedList对比

对比如下图：
对比

七、链表练习

删除链表中等于给定值 val 的所有节点
反转一个单链表
链表的中间节点
合并两个有序链表
链表分割
链表的回文结构
相交链表
环形链表

11.JavaSE_链表(单链表、双向链表）
roman's Blog
01-24 334
1、基本介绍： 为解决空间浪费等问题，应采用火车车厢的设计模式，动态进行车厢的挂载。 //单链表 class Node{ private Object data; private Node next; public Node(Object data) { this.data = data; } public Object getData...
单链表双向链表ADT_C语言项目
04-04
Singly Linked List： 1. DestroyList 2. InsertList 3. DeleteList 4. TraverseList 5. SearchList 6. ReverseList 7. IsLoopList 8. ReverseEvenList 9. FindMidNode ...5. TraverseList_DuL
单链表与双向链表
drunkpragrammer的博客
12-08 453
单链表 链表中的数据是以节点来表示的，每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 以"结点的序列"表示线性表称作线性链表(单链表) 单链表是链式存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。 双向链表 双向链表也叫双链表，是链表的一种，它的每个数据结
单向链表与双向链表
最新发布
2301_80338792的博客
09-04 754
当使用单向链表查看链表中某个节点的数据，可以使用快慢指针法。
链表(一) -- 单链表与双向链表
JeremyIverson的博客
02-12 1571
1.1 什么是链表？ 链表是有序的列表，但是它在内存中是存储如下 特点如下： 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表(带头结点) 逻辑结构示意图如下 1.2 单链表的应用实例 使用带head头的单向链表实现 –水...
《链表》——单向链表和双向链表（Java）
weixin_34018202的博客
05-20 315
完整的代码地址为：github 点击查看 单链表 单链表包括数据域和指向下一个节点的指针域，其结构如上图所示 首先定义一个数据类： class DATA{ //定义链表的一个节点 String key; //节点的关键字 String name; int age; } 定义一个单向链表类（包括以下...
【面试题精选】两数相加
weixin_43958974的博客
09-25 200
题目：两数相加 思路： 设置一个哨兵节点dummy和增长节点cur 定义一些辅助变量x,y,flag,sum x表示链表L1当前节点的值，空节点为0； y表示链表L2当前节点的值，空节点为0； sum表示x+y的和； flag表示sum/10,即向十位的溢出值 while循环，只要链表L1和链表L2不同时为空，就对L1和L2所指的当前节点作如下处理： 计算sum = x + y + flag; 计算flag = sum / 10; 用sum % 10的值在cur后面创建一个新节点； 循环结束
单链表双向链表java实现
03-27
在这个话题中，我们将深入探讨两种基本的线性数据结构——单链表和双向链表，并通过Java语言来实现它们。 单链表是一种线性数据结构，其中每个元素（称为节点）包含两个部分：数据域和指针域。数据域存储实际的数据...
C#数据结构之双向链表(DbLinkList)实例详解
09-03
在C#中，双向链表（Double-Linked List，简称DbLinkList）是一种重要的数据结构，它允许在列表中的每个元素都有两个链接：一个指向前一个元素，另一个指向后一个元素。这种数据结构使得在链表中进行前向和后向遍历变...
Python数据结构之双向链表的定义与使用方法示例
09-20
Python中的双向链表是一种线性数据结构，与单链表相比，它在每个节点中不仅包含指向下一个节点的指针，还包含一个指向前一个节点的指针。这使得双向链表可以在正向和反向两个方向上进行遍历，提高了操作的灵活性。 ...
单链表之双向链表
daa20的专栏
07-09 383
//DLinkList.h #ifndef _DLINKLIST_H_ #define _DLINKLIST_H_typedef void DLinkList; typedef struct _tag_DLinkListNode DLinkListNode; struct _tag_DLinkListNode { DLinkListNode* next; DLinkListNode*
单链表和双链表
SHUIHAN_007的博客
04-06 2952
单链表 链表是有序的列表，但是它在内存中的存储如下： 链表是以节点的方式来存储, 是链式存储 每个节点包含 data 域（存储数据），next 域（指向下一个节点） 链表的各个节点不一定是连续存储 链表分为带头节点的链表和 没有头节点的链表，根据实际的需求来确定 单链表的应用实例 使用带 head 头的单向链表实现 –水浒英雄排行榜管理完成对英雄人物的增删改查操作， 注: 删除和修改,查找 可以考虑学员独立完成，也可带学员完成 1) 第一种方法在添加英雄时，直接添加到链表的尾部 第二种方式在添加英
链表详解—单链表与双向链表
2401_83431652的博客
05-11 1127
我们可以用到重命名typedef，用STDateType代替链表要保存的数据类型。
双向链表，单链表
huangleijay的专栏
09-11 758
双链表就是双向链表，就是在单链表的每个结点里再增加一个指向其直接前趋的指针域prior,形成两条不同方向的链。由头指针head惟一确定。 双链表也可以头尾相链接构成双(向)循环链表。 双链表上的插入和删除时间复杂度均为O (1)。 ************************************************************ 单链表运算：·建立单链表·头插法：s->
双向链表和单向链表
HO_PE的博客
02-04 3459
概念: 双向链表也叫双链表，是链表的一种，是在操作系统中常用的数据结构，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱，其头指针 head 是唯一确定的。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点，这种数据结构形式使得双向链表在查找时更加方便，特别是大量数据的遍历。由于双向链表具有对称性，能方便地完成各种插入、删除等操作，但需要注意前后方向的操作 理...
数据结构第一谈：单链表双向链表的实现（基于Java）
小游子YKY的博客
01-06 2667
单链表 双向链表 基于Java的单链表双向链表实现
评论 191
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值