双向链表的实现

已于 2023-03-20 18:21:59 修改
阅读量68 收藏
点赞数 3
分类专栏： Java语法 链表 文章标签： 链表 数据结构 java
于 2023-03-20 14:04:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57248981/article/details/129665910
版权
文章详细介绍了如何使用Java创建一个实现了SeqList接口的DoubleLinkedList类，该类使用泛型处理各种数据类型。SeqList接口包含添加、删除、修改和查找元素等方法，DoubleLinkedList类通过内部DoubleNode节点类来存储和操作数据。文章展示了各个方法的实现，包括头插、尾插、按索引插入和删除元素，以及查找和修改元素等功能。
摘要由CSDN通过智能技术生成

目录

1.先建立一个接口SeqList,在其中定义方法,使用了泛型

2.实现一个类,DoubleLinkedList，其中有三个属性，

3.还有一个自定义的数据类型DoubleNode ,也有三个属性

4.让DoubleLinkedList实现SeqList接口，重写其所有方法，使用了泛型

代码注释及方法的重写如下：

1.先建立一个接口SeqList,在其中定义方法,使用了泛型

public interface SeqList<E>{
    //尾插
    void add(E element);
    //指定位置添加元素
    void add(int index, E element);

    //删除指定索引元素
    E remove(int index);
    //删除指定元素第一次出现的
    void removeElement(E element);
    //删除所有该值元素
    void removeAll(E elemnet);
    //修改指定下标元素
    E set(int index, E element);
    //查寻指定下标元素
    E get(int index);
    //判断是否存在
    boolean contains(E element);
    //查询指定元素下标，第一次出现
    int indexOf(E element);
}

2.实现一个类,DoubleLinkedList，其中有三个属性，

//保存结点的个数
private int size;
//头节点
private DoubleNode head;
//尾节点
private DoubleNode tail;

3.还有一个自定义的数据类型DoubleNode ,也有三个属性

//当前节点保存的数值
E val;
//当前节点的前结点的地址
DoubleNode prev;
//当前节点下一个结点的地址
DoubleNode next;

4.让DoubleLinkedList实现SeqList接口，重写其所有方法，使用了泛型

代码注释及方法的重写如下：

public class DoubleLinkedList<E> implements SeqList<E>{

    //保存结点的个数
    private int size;
    //头节点
    private DoubleNode head;
    //尾节点
    private DoubleNode tail;

    private

    class DoubleNode {
        //当前节点保存的数值
        E val;
        //当前节点的前结点的地址
        DoubleNode prev;
        //当前节点下一个结点的地址
        DoubleNode next;

        //构造器
        public DoubleNode() {

        }

        public DoubleNode(E val) {
            this.val = val;
        }

        public DoubleNode(E val, DoubleNode prev, DoubleNode next) {
            this.val = val;
            this.prev = prev;
            this.next = next;
        }
    }





    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for(DoubleNode x = head; x != null; x = x.next){
            sb.append(x.val).append("->");
            if(x == tail){
                sb.append("null");
            }
        }
        return sb.toString();
    }

   //在链表尾部添加元素
    @Override
    public void add(E element) {
        //创建一个新节点保存数据
        DoubleNode node = new DoubleNode(element);
        size++;
        //判断是否为空
        if(head == null){
            head = node;
        }else {
            tail.next = node;
            node.prev = tail;
        }
        tail = node;
    }

    //在链表头部添加元素
    public void addFirst(E element){
        //创建一个新的节点保存数据
        DoubleNode node = new DoubleNode(element);
        size++;
        //判断是否为空
        if(tail == null){
            tail = node;
        }else {
            head.prev = node;
            node.next = head;
        }
        head = node;
    }

    @Override
    public void add(int index, E element) {
        //判断是否为头尾节点
        if(index == 0){
            //头插
            addFirst(element);
            return;
        }
        if(index == size){
            //尾插
            add(element);
            return;

        }
        //一定有前驱后继
        //写一个方法找到在index的节点findNode
        //找到下标为index的节点
        DoubleNode next = findNode(index);
        DoubleNode prev = next.prev;
        DoubleNode node = new DoubleNode(element,prev,next);
        //先连接左边
        prev.next = node;
        //在连接右边
        next.prev = node;
        size++;
    }

    //找到在index的节点并返回
    private DoubleNode findNode(int index){
        //下标合法
        if(!rangeCheck(index)){
            throw new IllegalArgumentException("index illeagal!!");
        }
        if(index == 0){
            return head;
        }
        if(index == size-1){
            return tail;
        }
        //先创建一个空节点
        DoubleNode result = null;
        //根据下标位置判断是从前寻找还是从后寻找
        //012345
        if(index < size /2){
            //下标小于size的一半，从前往后找
            result = head;
            for(int i = 0; i < index; i++){
                result = result.next;
            }

        }else {
            //0123456789
            result = tail;
            for(int i = size-1; i > index; i--){
                result = result.prev;
            }
        }
        return result;
    }

    //判断下标是否合法的方法
    private boolean rangeCheck(int index){
        if(index < 0 || index >= size){
            return false;
        }
        return true;
    }

    //按照下标删除节点
    @Override
    public E remove(int index) {
        //判断下标是否合法
        if(!rangeCheck(index)){
            throw new IllegalArgumentException("index illeagal!!");
        }
        //判断是否是头尾节点
        if(index == 0){
            DoubleNode prev = head;
            head = head.next;
            size--;
            return prev.val;
        }
        if(index == size-1){
            DoubleNode prev = tail;
            tail = tail.prev;
            tail.next = null;
            size--;
            return prev.val;
        }
        //先找到需要删除的下标
        DoubleNode node = findNode(index);
        //找到其前驱
        DoubleNode prev = node.prev;
        //找到后继
        DoubleNode next = node.next;
        //先断左边
        prev.next = next;
        node.prev = null;
        //右边
        node.next = null;
        next.prev = prev;
        size--;
        return node.val;
    }

    //删除指定元素
    @Override
    public void removeElement(E element) {
        //遍历元素找到其下标
        DoubleNode prev = head;
        for(int i = 0; i < size; i++){
            if(prev.val.equals(element)){
                remove(i);
                return;
            }
            prev = prev.next;
        }
        System.out.println("链表中没有该元素~");
    }

    //删除所有指定元素
    @Override
    public void removeAll(E elemnet) {
        //防止删除元素过程中size的改变
        //将size的值先保存下来
        int len = size;
        DoubleNode prev = head;
        for (int i = 0; i < len; i++) {
            DoubleNode next = prev.next;
            if(prev.val.equals(elemnet)){
                removeElement(elemnet);
            }
            prev = next;
        }
    }

    //修改下标为index的元素值
    @Override
    public E set(int index, E element) {
        //判断合法
        if(!rangeCheck(index)){
            throw new IllegalArgumentException("index illeagal~~");
        }
        //找到需要修改的节点
        DoubleNode node = findNode(index);
        node.val = element;
        return node.val;

    }


    //上面的方法fingNode已经实现这个功能，这里就不再重复写
    @Override
    public E get(int index) {
        return null;
    }

    //判断元素是否在链表中
    @Override
    public boolean contains(E element) {
        DoubleNode prev = head;
        for(int i = 0; i < size; i++){
            if(prev.val.equals(element)){
                return true;
            }
            prev = prev.next;
        }
        return false;
    }

    //查询第一个出现指定元素的下标
    @Override
    public int indexOf(E element) {
        DoubleNode node = head;
        for(int i = 0; i < size; i++){
            if(node.val.equals(element)){
                return i;
            }
            node = node.next;
        }
        System.out.println("链表中没有该元素哦~");
        return -1;
    }
}

小锦鲤yaw
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
双向链表实现
hxy1625309592的博客
12-15 2138
1.1 基本介绍 1、单向链表优缺点 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。 单向链表不能自我删除，需要靠辅助节点 ，而双向链表则可以自我删除。 2、双向链表基本介绍 双向链表也叫双向表，是链表的一种，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域(data)用来存储数据，其中一个指针域(next)用来指向其后继结点，另一个指针域用来指向前驱结点(prev指针)。链表的头结点的数据域不存储数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一
带头双向链表实现(带图详解)
fw5884179的博客
08-07 564
带头双向链表实现
双向链表实现栈
m0_56398287的博客
10-03 1336
双向链表来实现栈
【数据结构】双向链表实现
m0_73367097的博客
03-26 1691
双向链表的定义与实现
基于 HashMap 和 双向链表实现 LRU
ikun的博仔的博客
06-26 1048
基于HashMap和双向链表实现LRU
基于双向链表实现的栈
Gee_Zer的博客
08-15 3829
看了LinkedList的源码，明白了LinkedList底层使用的是双向链表，一直想找个机会实现一下双向链表，今天写到力扣的每日一题20.有效的括号，正好此题需要使用到栈，所以借此机会来自己实现一下基于双向链表实现的栈，实现栈之前要了解以下知识 1.什么是双向链表 双向链表是指一个节点有一个数据域，两个指针域，一个指针域指向上一个节点，一个指针域指向下一个节点，现在将指向上一个节点的指针域命名为pre，将指向下一个节点的指针域命名为next，节点命名为node，一个合格的双向链表如下图所示 中间的nod
用双向链表实现栈（C）
u014801954的博客
05-15 4886
目录 一.结构定义： 二.结构操作 三.测试代码 四.运用
使用线程安全型双向链表实现简单 LRU Cache 模拟
热门推荐
苏州程序大白的博客
11-16 1万+
使用线程安全型双向链表实现简单 LRU Cache 模拟目录????博主介绍前言1、动机1.1、要解决的问题2、系统设计2.1、系统总体框架2.2、系统功能模块2.3 系统整体流程3、数据结构设计4、关键技术与系统实现4.1、生成访问序列4.2 各进程的推进4.3、修改链表结构的相关方法实现4.4、访问链表的相关方法实现4.5、应用封装层的实现4.6、统计缓冲区命中率5、系统运行结果5.1、运行环境5.2、运行与测试结果5.2.1、运行结果5.2.2、链表方法测试6、调试与改进????作者相关的文章、资源分
java模拟双向链表实现
congge
03-10 6332
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点 下图是双向链表的逻辑结构图，和单链表不同的是，双向链表中每个节点包含两个节点的指针引用，和一个数据域，这两个节点分别指向前一个节点和后一个节点； 双向链表的这种结构比起单链表，其改进之处正在于此，通过对前后节点的引用可以使得在...
双向链表实现(c/c++)
qq_52095705的博客
11-16 2219
前言 数据结构还是得来一手。 一.关于链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。链表通过指针域能把多个元素串联起来。 一般的链表中每个元素只有一个指向下一个元素的指针域，而我们的双向链表却有两个指针域，其中一个指针域指向下一个元素，另一个指针域指向这个元素的上一个元素。 接下来看程序
python双向链表实现实例代码
12-25
python双向链表实现代码： 复制代码 代码如下:#!/usr/bin/python# -*- coding: utf-8 -*- class Node(object): def __init__(self,val,p=0): self.data = val self.next = p self.prev = p class LinkList...
双向链表实现贪吃蛇游戏（C语言版）
12-26
在本文中，我们将深入探讨如何使用C语言和双向链表实现经典的贪吃蛇游戏。双向链表是一种数据结构，它允许我们在列表中的任何位置轻松地插入和删除元素，这使得它成为实现动态游戏世界，如贪吃蛇，的理想选择。 1. ...
C++的双向链表实现
04-15
**C++的双向链表实现** 在C++中，双向链表是一种数据结构，它包含节点，每个节点都有指向其前一个节点和后一个节点的指针。这使得在链表中的导航比单链表更加灵活，因为可以向前或向后移动。双向链表在许多算法和...
C++双向链表实现简单通讯录
08-19
C++双向链表实现简单通讯录 在本文中，我们将详细介绍C++双向链表实现简单通讯录的实现方法。我们将从头开始，了解C++双向链表的基本概念，然后逐步实现一个简单的通讯录系统。 首先，让我们了解一下C++双向链表...
【Redis】Redis 底层的数据结构（结合源码）
秋玄的博客
08-22 937
Redis 底层数据结构详解
【数据结构】线性表的顺序表示（顺序表的定义和基本操作）
zhousanguhe的博客
08-23 363
线性表的顺序表示（顺序表的定义和基本操作：初始化/插入/删除/查找）
二叉搜索树：数据结构之美
最新发布
wgr050505的博客
08-26 397
本文介绍了二叉搜索树的基本概念、主要操作以及一些高级主题。通过学习这些内容，您不仅能够理解二叉搜索树的工作原理，还能够掌握如何有效地使用它们来解决实际问题。此外，本文还探讨了自平衡二叉搜索树的概念，这是处理大规模数据集时的一个重要工具。
重新理解操作系统（linux）、编程语言和算法与数据结构
crawer
08-23 447
怎样理解操作系统（linux）、编程语言和算法与数据结构
算法的学习笔记—二叉搜索树的后序遍历序列(牛客JZ33)
业精于勤，荒于嬉
08-22 857
通过递归地判断数组的子序列是否满足二叉搜索树的性质，我们可以有效地判断一个数组是否是某二叉搜索树的后序遍历序列。这个方法在逻辑上比较直观，并且能够处理复杂的情况，尽管其时间复杂度为O(n^2)，但在实际应用中仍然是一个实用的算法。希望通过这篇文章，大家能够更加深入地理解二叉搜索树及其后序遍历的相关概念，并掌握如何通过编程来解决这类问题。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVC。
双向链表实现多级菜单
09-22
以下是一个使用双向链表实现多级菜单的示例代码： ```python class MenuItem: def __init__(self, label): self.label = label self.child = None self.parent = None self.next_sibling = None def create_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值