Java实现无头双向链表

最新推荐文章于 2023-03-15 11:53:31 发布
最新推荐文章于 2023-03-15 11:53:31 发布
阅读量154 收藏
点赞数
分类专栏： JavaSE 文章标签： 链表 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46660141/article/details/107746122
版权

创建空的成员变量并用构造函数初始化

class ListNode {
    public int data;
    public ListNode next;//节点引用
    public ListNode prev;//节点前驱

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

头节点和尾结点

public class DoubleLinkedList {
    public ListNode head;
    public ListNode tail;

头插法

    //头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        if (this.head == null) {
            this.head = node;
            this.tail = 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.tail = node;
            this.head = node;
        } else {
            this.tail.next = node;
            node.prev = this.tail;
            this.tail = node;
        }
    }

在这里插入图片描述

打印链表

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

任意位置插入，第一个数据节点为0的下标
计算链表长度

   //任意位置插入，第一个数据节点为0的下标
    public void addIndex (int index,int data) {
        if (index < 0 || index > size()) {
            return;
        }
        if (index == 0) {
            addFirst(data);
            return;
        }
        if (index == size()) {
            addLast(data);
            return;
        }
        ListNode cur = searchIndex(index);
        ListNode node = new ListNode(data);
        node.next = cur;
        node.prev = cur.prev;
        cur.prev.next = node;
        cur.prev = node;
    }
    public ListNode searchIndex(int index) {
        ListNode cur = this.head;
        while (index > 0) {
            cur = cur.next;
            index --;
        }
        return cur;
    }
    //求链表长度
    public int size() {
        ListNode cur = this.head;
        int count = 0;
        while (cur != null) {
            cur = cur.next;
            count++;
        }
        return count;
    }

在这里插入图片描述

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

    //删除第一次出现关键字为key的点
    public void remove(int key) {
        ListNode cur = this.head;
        while (cur != null) {
            if (cur.data == key) {
                //删除的是否为头节点
                if (cur == this.head) {
                    this.head = this.head.next;
                    this.head.prev = null;
                } else {
                    cur.prev.next = cur.next;
                    if (cur.next != null) {
                        //删除的不是尾结点
                        cur.next.prev = cur.prev;
                    } else {
                        this.tail = cur.prev;
                    }
                }
                //删除完成
                return;
            } else {
                cur = cur.next;
            }
        }
    }

删除所有key节点

    public void removeAllkey (int key) {
        ListNode cur = this.head;
        while (cur != null) {
            if (cur.data == key) {
                //删除的是否为头节点
                if (cur == this.head) {
                    this.head = this.head.next;
                    this.head.prev = null;
                } else {
                    cur.prev.next = cur.next;
                    if (cur.next != null) {
                        //删除的不是尾结点
                        cur.next.prev = cur.prev;
                    } else {
                        this.tail = cur.prev;
                    }
                }
            }
            cur = cur.next;
        }
    }

清空链表

    //清空回收链表
    public void clear() {
        ListNode cur = this.head;
        ListNode curNext;
        while (cur != null) {
            curNext = cur.next;
            cur.next = null;
            cur.prev = null;
            cur = curNext;
        }
        this.head = null;
        this.tail = null;
    }

查找是否含有关键字key

   //查找是否包含关键字key
    public boolean contains (int key) {
        if (head == null) {
            return false;
        }
        ListNode cur = this.head;
        while (cur != null) {
            if (cur.data == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
}

测试代码

public class Test {
    public static void main(String[] args) {
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.addFirst(3);
        doubleLinkedList.addFirst(3);
        doubleLinkedList.addFirst(3);
        doubleLinkedList.addLast(4);
        doubleLinkedList.addLast(5);
        doubleLinkedList.addLast(3);
        //3 2 1 4 5 6
        doubleLinkedList.display();

        doubleLinkedList.addIndex(3,999);
        //3 2 1 999 4 5 6
        doubleLinkedList.display();

        doubleLinkedList.remove(5);
        doubleLinkedList.display();

        System.out.println(doubleLinkedList.contains(9));

        doubleLinkedList.removeAllkey(3);
        doubleLinkedList.display();

        doubleLinkedList.clear();
        System.out.println("dadedsffw");
    }
}

完整代码

import java.util.List;

/**
 * @Author 袁媛
 * @Date 2020/7/31
 * @Time 10:54
 */

class ListNode {
    public int data;
    public ListNode next;
    public ListNode prev;

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

public class DoubleLinkedList {
    public ListNode head;
    public ListNode tail;
    //头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        if (this.head == null) {
            this.head = node;
            this.tail = 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.tail = node;
            this.head = node;
        } else {
            this.tail.next = node;
            node.prev = this.tail;
            this.tail = node;
        }
    }
    //打印链表
    public void display() {
        ListNode cur = this.head;
        while (cur != null) {
            System.out.print(cur.data + " ");
            cur = cur.next;
        }
        System.out.println();
    }
    //任意位置插入，第一个数据节点为0的下标
    public void addIndex (int index,int data) {
        if (index < 0 || index > size()) {
            return;
        }
        if (index == 0) {
            addFirst(data);
            return;
        }
        if (index == size()) {
            addLast(data);
            return;
        }
        ListNode cur = searchIndex(index);
        ListNode node = new ListNode(data);
        node.next = cur;
        node.prev = cur.prev;
        cur.prev.next = node;
        cur.prev = node;
    }
    public ListNode searchIndex(int index) {
        ListNode cur = this.head;
        while (index > 0) {
            cur = cur.next;
            index --;
        }
        return cur;
    }
    //求链表长度
    public int size() {
        ListNode cur = this.head;
        int count = 0;
        while (cur != null) {
            cur = cur.next;
            count++;
        }
        return count;
    }
    //删除第一次出现关键字为key的点
    public void remove(int key) {
        ListNode cur = this.head;
        while (cur != null) {
            if (cur.data == key) {
                //删除的是否为头节点
                if (cur == this.head) {
                    this.head = this.head.next;
                    this.head.prev = null;
                } else {
                    cur.prev.next = cur.next;
                    if (cur.next != null) {
                        //删除的不是尾结点
                        cur.next.prev = cur.prev;
                    } else {
                        this.tail = cur.prev;
                    }
                }
                //删除完成
                return;
            } else {
                cur = cur.next;
            }
        }
    }
    //删除所有key节点
    public void removeAllkey (int key) {
        ListNode cur = this.head;
        while (cur != null) {
            if (cur.data == key) {
                //删除的是否为头节点
                if (cur == this.head) {
                    this.head = this.head.next;
                    this.head.prev = null;
                } else {
                    cur.prev.next = cur.next;
                    if (cur.next != null) {
                        //删除的不是尾结点
                        cur.next.prev = cur.prev;
                    } else {
                        this.tail = cur.prev;
                    }
                }
            }
            cur = cur.next;
        }
    }
    //清空回收链表
    public void clear() {
        ListNode cur = this.head;
        ListNode curNext;
        while (cur != null) {
            curNext = cur.next;
            cur.next = null;
            cur.prev = null;
            cur = curNext;
        }
        this.head = null;
        this.tail = null;
    }
    //查找是否包含关键字key
    public boolean contains (int key) {
        if (head == null) {
            return false;
        }
        ListNode cur = this.head;
        while (cur != null) {
            if (cur.data == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
}
小猪媛不圆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 实现无头双向链表的基本操作
近未来
07-13 253
无头双向链表的结构： 节点结构 class Node { private int data; private Node next; private Node prev; public Node(int data) { this.data = data; this.prev = null; this.next = n...
Java双向链表的实现
Become hunger become strong
03-03 168
Java双向链表的实现 定义：双向链表中的数据结点有两个指针，分别指向直接后继和直接前驱，所以从双向链表中的任一结点开始，都可以很方便的访问它的前驱结点和后继结点。 链表节点的定义 在单向链表定义的前提下添加pre，表示指向当前节点的前一个。 class PersonNode { // number是值，从小到大；可以根据需要调节 public int number; public String name; public String nickName; publ
数据结构系列5——链表（无头双向非循环链表）
最新发布
小白的博客
03-15 164
MyLinkedList (无头双向非循环)+ LInkedLIst
【JAVA】双向链表的基本操作（增删查改）代码详解
qq_45864756的博客
06-16 361
关于双向链表的学习，简单易懂
【数据结构】链式存储：链表（无头双向链表实现）
m0_72161237的博客
01-04 795
🌈节点由val域(数据域)，prev(前驱），next(后继)，对于prev域，其是引用类型，存放上一个节点的地址；对于next域，其是引用类型，存放下一个节点的地址。
Java实现双向链表
mousekingking的专栏
07-12 674
双向链表和单向链表的不同之处在于，双向链表
Java实现双向链表(两个版本)
09-02
主要介绍了Java实现双向链表(两个版本)的相关资料,需要的朋友可以参考下
java实现单链表、双向链表
09-02
以上就是Java中单链表和双向链表的基本实现和操作。这些基础数据结构在许多实际编程问题中都有应用，例如在实现LRU缓存策略、模拟队列和栈等高级数据结构时。理解并熟练掌握链表是提升编程技能的重要一步。
doublelink.zip_DoubleLink java_双向链表实现
09-24
在本文中，我们将深入探讨如何使用Java编程语言实现一个高效的双向链表数据结构，并通过测试用例进行验证。首先，让我们了解双向链表的基本概念。 双向链表是一种线性数据结构，其中每个节点包含两个指针，分别指向...
java 实现双向链表实例详解
08-31
Java 实现双向链表实例详解 Java 实现双向链表实例详解是一种基本的数据结构，在 Java 中 LinkedList 已经实现了这种结构，但是作为开发者，也要拥有自己显示这种结构的能力。双向链表是一种动态的数据结构，它可以...
java list翻转_java实现翻转链表
weixin_39955825的博客
12-22 340
输入一个链表，反转链表后，输出链表的所有元素。本来是想利用栈，把链表节点一个一个压人栈中，然后一个一个弹出链接到原链表的尾部，代码如下：public ListNode ReverseList(ListNode head){if(head==null)returnnull;ListNodelast=head;Stackstack=newStack();while(last.next!=null){s...
链表之无头双向非循环链表（Java语言）
qq_57563254的博客
12-06 819
无头双向链表（Java语言）前言介绍无头双向非循环链表节点类——ListNode链表类——MyLinkedList打印链表得到链表的长度查找是否包含关键字key插入一个元素——头插法插入一个元素——尾插法插入一个元素——任意位置插入寻找index位置的节点删除第一次出现key的节点删除所有key的节点清空链表总代码 前言 经过对于顺序表和单链表的熟悉我们已经对于数据结构有了简单的认识，这次我们了解无头双向链表的相关知识。 介绍 首先我们先看一下双向链表的结构： 这就是一个非常简单的双向链表，一个节点可以找
无头双向链表方法
yanweiding的博客
10-29 114
public class DoubleLinkedList { //头插法 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的节点 publi
无头双向链表
Fighting261的博客
05-02 216
class Node { public int data;//数据 public Node next;//后继信息 public Node prev;//前驱信息 public Node(int data) { this.data = data; } } public class MyLinkedList { public No...
无头双向链表的实现
weixin_45662626的博客
02-24 216
上一篇：不带头节点的单链表的实现 无头双向链表的实现 无头双向链表就是没有头节点，每个节点都有next和前驱prev的链表。 如下图示意： 我们来开始写代码，无头双向链表的实现： class Node{ public int data; public Node next; public Node prev; public Node(int data) { this.data = data; } } public class MyLinkedList
链表之双向链表（有头and无头）
m0_48810566的博客
10-26 421
链表之双向链表 话不多说，直接看代码，你懂的！！！！！！ 无头双向链表的定义： class ListNode { public int val; public ListNode next; public ListNode prev; public ListNode(int val) { this.val = val; } } public class DoubleList { public ListNode head; public
给定一个十进制整数，如何转换成二进制形式？如何转换成十六进制形式？
weixin_46660141的博客
07-16 1160
转换成二进制 简单的来说就是，整数部分除二取余，小数部分乘二取整。 比如转换10.25为二进制： 首先看整数部分： 10/2=5余数是0； 5/2=2余数是1； 2/2=1（整商）余数是0. 取最后的整商，然后余数倒着数回去，即1010 再看小数部分： 0.252=0.5（整数部分是0） 0.52=1（整数部分是1）。 则小数部分的二进制为01，整数部分和小数部分合起来就是1010.01，转换成功。 转换成十六进制 有了上面二进制的转换，转换成16进制就更简单了，以小数点为界，整数部分向左数，每四位.

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值