Java实现双向链表及其常规操作

已于 2022-03-16 19:22:47 修改
阅读量2.5k 收藏 29
点赞数 18
分类专栏： Java 数据结构 文章标签： 链表 java 数据结构
于 2022-03-16 19:03:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58284486/article/details/123531837
版权

数据结构链表的学习结束了，我已经将重要的三种链表的简单实现整理并发布在了博客上，希望我的文章可以给有需要的朋友们带来帮助，也希望大家可以指出我存在的问题，共同进步，2022年冲刺大厂☺☺(*￣︶￣)

顺序表的简单实现：顺序表的简单实现

单链表的简单实现：单链表的简单实现

双向链表的定义

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表任意一个结点开始，都可以很方便的访问它的前驱结点和后继结点。

简易的双向链表模型

目录

模拟实现简单的双向链表

定义结点类

初始化

  打印双向链表 

头插法创建双向链表 

尾插法创建双向链表 

判断双向链表是否包含关键字key

求双向链表的长度 

寻找待插入的位置

双向链表的插入 

按值查找待删除的位置

双向链表的删除(第一次出现的key)

双向链表的删除(删除所有的key值) 

双向链表的清空操作

完整代码 

模拟实现简单的双向链表

在自己实现的双向链表中需要包括以下功能：增加元素（头插、尾插）、查找元素、修改元素、删除元素、获取链表的长度、清空链表.

定义结点类

每个结点包括两个指针、数据域还有结点数据域的构造方法，则根据双向链表的定义，可以建立如下结点类

class ListNode {
    public int val;
    public ListNode next;//前驱信息
    public ListNode prev;//后继信息

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

初始化

last用来标记双向链表的尾结点，head用来标记它的头结点.

public class MyLinkedList {
    public ListNode head;//标记双向链表的头结点
    public ListNode last;//标记双向链表的尾结点
}

  打印双向链表 

双向链表的打印可以有两种方法，一种是根据head来正向打印链表，另一种是根据last标记的尾结点来反向打印.

①正向打印

    //利用head正向打印双向链表
    public void display() {
        ListNode cur = this.head;
        while (cur != null) {
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
    }

②反向打印 

    //利用last反向打印双向链表
    public void display1() {
        ListNode cur = this.last;
        while(cur != null) {
            System.out.print(cur.val+" ");
            cur = cur.prev;
        }
    }

头插法创建双向链表 

在对双向链表进行头插法插入时，需要考虑到该结点的prev和next域，相较于单链表来说比较麻烦，具体插入细节如下图所示：

假设目前双向链表有四个结点，现要头插法插入一个结点，则：

在进行插入时，需要使head的prev指向新建的node结点，node结点的next指向当前的head即可完成头插法插入.

具体代码如下：

    //头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        if(this.head == null) {
            this.head = node;
            this.last = node;
        } else {
            node.next = this.head;
            this.head.prev = node;
            this.head = node;
        }
    }

尾插法创建双向链表 

在使用尾插法插入时，可以直接利用last标记的尾结点来实现尾插插入，将last.next指向node，并将node.prev指向当前的last，最后再令last = node，即可完成尾插法插入，最终last依旧保存链表最后一个结点的信息

    //尾插法
    public void addLast (int data) {
        ListNode node = new ListNode(data);
        if(this.head == null) {
            this.head = node;
            this.last = node;
        } else {
            this.last.next = node;
            node.prev = this.last;
            this.last = node;
        }
    }

判断双向链表是否包含关键字key

在进行判断时，有两种方式，一种是利用head从头到尾遍历链表来判断是否包含关键字key，另一种方式是利用last从尾到头来遍历链表判断是否包含关键字key.下述代码为从头到尾遍历：

    //判断双向链表是否包含关键字key
    public boolean contains(int key) {
        ListNode cur = this.head;
        while(cur != null) {
            cur = cur.next;
            if(cur.val == key) {
                return true;
            }
        }
        return false;
    }

求双向链表的长度 

在求长度时，也是两种方法，一种从头到尾的遍历方式，另一种为从尾到头的头的方式，下述代码列举从尾到头的遍历求长度方式.

    //得到单链表的长度
    public int size() {
        ListNode cur = this.last;
        int size = 0;
        while(cur != null) {
            cur = cur.prev;
            size++;
        }
        return size;
    }

寻找待插入的位置

根据给定的插入位置，来寻找到要插入位置现在的结点

    //寻找要插入的位置
    public ListNode findIndex(int index) {
        int pos = 0;
        ListNode cur = this.head;
        while(pos != index) {
            cur = cur.next;
            pos++;
        }
        return cur;
    }

双向链表的插入 

在进行插入前，首先要对特殊情况进行单独处理：

①插入位置是否合法；

②如果是插入在第一个位置，则直接利用头插法插入；

③如果插入在最后一个位置，则直接利用尾插法插入.

如果不满足上述三种情况，则进行正常插入，如下图所示，假设要将新建的node结点插入在第二个位置

要插入在第二个位置，所以定义cur使其处在地址为0x111的位置，之后再对该结点的前驱和后继进行处理即可.

具体代码如下 

    //指定位置插入key
    public void addIndex(int index, int data) {
        if(index < 0 || index > size()) {
            throw new RuntimeException("操作位置不合法");
        }
        if(index == 0) {
            addFirst(data);
            return;
        }

        if(index == size()) {
            addLast(data);
            return;
        }
        ListNode node = new ListNode(data);
        ListNode cur = findIndex(index);
        cur.prev.next = node;
        node.prev = cur.prev;
        node.next = cur;
        cur.prev = node;
    }

按值查找待删除的位置

遍历链表来寻找等于key的结点即可

    //按值查找结点位置
    public ListNode findKeyIndex(int key) {
        ListNode cur = this.head;
        while(cur != null) {
            if(cur.val == key) {
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }

双向链表的删除(第一次出现的key)

在进行删除操作之前，需要对以下特殊情况进行处理：

①判断链表是否为空，若为空则不能进行删除操作，抛出异常；

②判断待删除的位置是否是头结点，如果是，则直接特殊处理；

如若不满足上述特殊情况，则进行正常的删除操作，假设目前的链表如下图所示，需要删除key == 4的结点，则首先使cur处在val值为4的结点处：

 则利用cur对其前驱和后继进行操作即可实现删除操作

具体代码如下： 

    //删除第一次出现关键字为key的节点
    public void remove(int key) {
        if(this.head == null) {
            throw new RuntimeException("链表为空，无法进行删除操作");
        }
        if(this.head.val == key) {
            this.head = this.head.next;
            if(head != null) {
                this.head.prev = null;
            }
            return;
        }
        ListNode cur = findKeyIndex(key);
        if(cur == last) {
            this.last = this.last.prev;
            if(head != null) {
                this.last.next = null;
            }
            return;
        }
        cur.prev.next = cur.next;
        cur.next.prev = cur.prev;
    }

双向链表的删除(删除所有的key值) 

在进行删除操作前首先需要判断链表是否空，如果为空则直接抛出异常，停止程序；

首先令cur = head.next，将头结点和尾结点空出来，在程序的最后对这两个结点进行特殊处理，利用cur遍历链表，如果遇到结点的值等于key值的情况，则进行删除，删除流程与删除单一删除基本一致，cur遍历的停止条件是 cur == last.

再对头结点和尾结点进行判断即可完成该操作.

    //删除所有值为key的节点
    public void removeAll(int key) {
        if(this.head == null) {
            throw new RuntimeException("链表为空，无法进行删除操作");
        }
        ListNode cur = this.head.next;
        while(cur != this.last) {
            if(cur.val == key) {
                cur.prev.next = cur.next;
                cur.next.prev = cur.prev;
            }
            cur = cur.next;
        }
        if(this.head.val == key) {
            this.head = this.head.next;
            if(head != null) {
                this.head.prev = null;
            }
        }
        if(this.last.val == key) {
            this.last = this.last.prev;
            if(head != null) {
                this.last.next = null;
            }
        }
    }

双向链表的清空操作

双向链表的清空操作需要同时将head和last置为null，如果只将head置为null，则该双链表正向的断开了，但是反向链接还在，例如：

因此需要同时进行置空操作

    //清空单链表
    public void clear(){
        this.head = null;
        this.last = null;
    }

完整代码 

package doublelinkedlist;

class ListNode {
    public int val;
    public ListNode next;//前驱信息
    public ListNode prev;//后继信息

    public ListNode(int val) {
        this.val = val;
    }
}
public class MyLinkedList {
    public ListNode head;//标记双向链表的头结点
    public ListNode last;//标记双向链表的尾结点

    //头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        if(this.head == null) {
            this.head = node;
            this.last = node;
        } else {
            node.next = this.head;
            this.head.prev = node;
            this.head = node;
        }
    }

    //尾插法
    public void addLast (int data) {
        ListNode node = new ListNode(data);
        if(this.head == null) {
            this.head = node;
            this.last = node;
        } else {
            this.last.next = node;
            node.prev = this.last;
            this.last = node;
        }
    }

    //寻找要插入的位置
    public ListNode findIndex(int index) {
        int pos = 0;
        ListNode cur = this.head;
        while(pos != index) {
            cur = cur.next;
            pos++;
        }
        return cur;
    }
    //指定位置插入key
    public void addIndex(int index, int data) {
        if(index < 0 || index > size()) {
            throw new RuntimeException("操作位置不合法");
        }
        if(index == 0) {
            addFirst(data);
            return;
        }

        if(index == size()) {
            addLast(data);
            return;
        }
        ListNode node = new ListNode(data);
        ListNode cur = findIndex(index);
        cur.prev.next = node;
        node.prev = cur.prev;
        node.next = cur;
        cur.prev = node;
    }

    //判断双向链表是否包含关键字key
    public boolean contains(int key) {
        ListNode cur = this.head;
        while(cur != null) {
            cur = cur.next;
            if(cur.val == key) {
                return true;
            }
        }
        return false;
    }

    //打印双向链表,正向打印
    public void display() {
        ListNode cur = this.head;
        while (cur != null) {
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
    }

    //打印双向链表,反向打印
    public void display1() {
        ListNode cur = this.last;
        while(cur != null) {
            System.out.print(cur.val+" ");
            cur = cur.prev;
        }
    }

    //按值查找结点位置
    public ListNode findKeyIndex(int key) {
        ListNode cur = this.head;
        while(cur != null) {
            if(cur.val == key) {
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }

    //删除第一次出现关键字为key的节点
    public void remove(int key) {
        if(this.head == null) {
            throw new RuntimeException("链表为空，无法进行删除操作");
        }
        if(this.head.val == key) {
            this.head = this.head.next;
            this.head.prev = null;
            return;
        }
        ListNode cur = findKeyIndex(key);
        if(cur == last) {
            this.last = this.last.prev;
            this.last.next = null;
            return;
        }
        cur.prev.next = cur.next;
        cur.next.prev = cur.prev;
    }

    //删除所有值为key的节点
    public void removeAll(int key) {
        if(this.head == null) {
            throw new RuntimeException("链表为空，无法进行删除操作");
        }
        ListNode cur = this.head.next;
        while(cur != this.last) {
            if(cur.val == key) {
                cur.prev.next = cur.next;
                cur.next.prev = cur.prev;
            }
            cur = cur.next;
        }
        if(this.head.val == key) {
            this.head = this.head.next;
            this.head.prev = null;
        }
        if(this.last.val == key) {
            this.last = this.last.prev;
            this.last.next = null;
        }
    }

    //得到单链表的长度
    public int size() {
        ListNode cur = this.last;
        int size = 0;
        while(cur != null) {
            cur = cur.prev;
            size++;
        }
        return size;
    }

    //清空单链表
    public void clear(){
        this.head = null;
        this.last = null;
    }

}

Li_yizYa
关注
  • 18
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 18
    评论
专栏目录
Java实现双向链表(两个版本)
09-02
主要介绍了Java实现双向链表(两个版本)的相关资料,需要的朋友可以参考下
JAVA双向链表反转实现
06-10
通过java实现的双向链表，及反转功能，可能对面试有用哦
Java实现双向链表
keke的博客
10-07 3741
Java实现双向链表
双向链表中插入元素的几种方式
zhangwei8598的博客
03-21 1万+
双链表插入节点
双向链表的操作
e.g.:
11-06 1780
指针域：用于指向当前节点的直接前驱节点；数据域：用于存储数据元素。指针域：用于指向当前节点的直接后继节点；
双向链表的插入
weixin_52634719的博客
09-20 9320
概览: 已知p指针，那么a结点的地址就在p指针所指结点的prior里存着， a结点要变成s的前驱， 所以要给s的Prior域赋值，赋的是a结点的地址，即p的prior。 接下来 将s结点变成a结点的后继，就要给a结点的next域赋值，赋的是新插入结点的地址，而他此时在s里存着 a结点的next域就是p的前驱结点的next，即p->prior->next=s; 接下来s还要作为b的前驱，则又需要修改两个指针 一个呢是b作为新...
数据结构学习系列之双向链表的三种插入方式
qq_41878292的博客
10-14 1025
5.如果存在，则第0个结点的前驱指针指向新结点的地址，即。）此处存储的是第0个结点的地址，可能是空指针（6.最后，头结点的后继指针（4.判断是否有第0个结点；）指向头结点的地址，即。）指向新结点的地址（
数据结构（线性结构：双链表）
qq_66298799的博客
09-16 1078
数据结构（线性结构：双链表详细解析）
JAVA实现双向链表的增删功能的方法
08-27
本篇文章主要介绍了JAVA实现双向链表的增删功能的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
双向链表及其基本操作
10-29
C语言，实现双向链表以及其基本操作，基本操作：链表初始化、创建、查询、删除、释放，查询和删除均有两种方式，一种是按照值，另一种是按照结点的序号。
java 实现双向链表实例详解
08-31
主要介绍了java 实现双向链表实例详解的相关资料,需要的朋友可以参考下
双向链表的删除和插入
热门推荐
m0_61395860的博客
02-05 1万+
一、初始操作 双向链表定义如下： #include<stdio.h> #include<stdlib.h> typedef struct DLnode{ int data; struct DLnode *prev,*next; }DLnode,*DLinklist; 尾插法创建： void Create(DLinklist &L){ L=(DLinklist)malloc(sizeof(DLnode)); L->next=NULL; D
单链表与双链表，常见的插入和删除
yhm12580的博客
07-31 1307
else {} }这段代码是一个用于将元素插入单链表末尾的函数。函数的定义是 void SlistPushBack(SlistNode** pphead, SlistDateType x)，它接受两个参数：一个指向单链表头指针的指针 pphead 和要插入的元素值 x。首先，代码中使用 malloc 函数为新节点分配内存空间 sizeof(SlistNode)，并将返回的指针赋值给 newnode 变量。
形象的理解双向链表之插入
weixin_44425713的博客
09-22 1136
形象的理解双向链表之插入 总体思路—前驱后继 链表中前驱和后继就是指当前结点的前一个和后一个结点分别是什么，我们把要插入的结点作为当前结点。如图所示： q是为了便于理解自己添加的，对于原链表，实际上有： p->prior=q; p->prior->next=p;//q->next=p能理解吧？把q用p->prior代就完事了 一.s的前驱和后继 1.前驱（即图①）—和前面结点相连 s->prior=q; 2.后继（即图③）—和后面结点相连 s->next=p;
【初阶数据结构02】Java实现双向链表
kk702392702的博客
12-12 464
如果新节点的编号比链表中已有的任何一个节点的编号都要大或者加入的是第一个节点，那么加入这个新节点就相当于在末尾添加，添加的方法与第一种方法相同。单向链表虽然有很多的优点和好处，但也是有一些局限性的，有些功能是单向链表很难实现或实现不了的，这时候就需要我们的双向链表出场了！因为双向链表的遍历（显示）和修改操作和单向链表是一样的，所以今天我就只该大家演示双向链表的添加和删除操作了。如果要删除的节点刚好是最后一个节点，就不能用上面这种方法删除，因为最后一个节点的next为null。
java双向链表的长度_双向链表的原理与实现
weixin_39800990的博客
02-25 322
一、双向链表原理顾名思义，双向链表跟单链表和循环列表最大的差别，就是同时拥有前驱指针和后驱指针，基于这一个特性，查询某结点的前一个结点，时间复杂度可以达到O(1)，非常高效。双向链表的存取时间复杂度是O(n)，增删时间复杂度为O(1)，跟其他链表没啥区别。双向链表表示意图：双向链表.jpg所以双向链表的结点定义如下：class Node{Object data; //元素值Node pre; //...
双向链表的插入操作
weixin_34014277的博客
12-20 198
双向链表的插入操作 转载于:https://www.cnblogs.com/LoveFishC/archive/2012/12/20/3845820.html
关于Ribbon在SpringCloudAlibaba2021.1版本中，找不到服务实例
最新发布
aoxiaojun的博客
04-12 440
关于Ribbon在SpringCloudAlibaba2021.1版本中，找不到服务实例

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Li_yizYa

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

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

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

打赏作者

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

抵扣说明：

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

余额充值