链表MyLinkedList的具体实现

最新推荐文章于 2024-07-16 22:26:22 发布
最新推荐文章于 2024-07-16 22:26:22 发布
阅读量365 收藏 4
点赞数 6
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69160679/article/details/137173357
版权
本文详细介绍了无头单向非循环链表和无头双向非循环链表的实现，包括接口定义、类结构、方法实现以及测试示例，展示了如何在Java中操作这些数据结构。
摘要由CSDN通过智能技术生成

文章目录

前言

今天我学习了一种新的数据结构–链表，我将分享给大家两种链表的具体实现。

一、无头单向非循环链表

最简单的链表，一般不会单独用来储存数据，实际中作为其他数据结构的子结构，
如：图的邻接表。

1.无头单向循环链表的实现

1.1List接口

用来存放即将实现的方法

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

1.2MySingLlistl类

里面将具体实现List接口中的方法
1.链表的基本属性

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

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

而head节点应该定义在ListNode的外部

public ListNode head;

2.具体方法的实现

public class MySingleList implements IList {
    static class ListNode{
        public int val;
        public  ListNode next;

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

    @Override
    //插入数据的时候先绑后面的，防止数据丢失
    public void addFirst(int data) {
        ListNode node=new ListNode(data);
        node.next=head;
        head=node;
    }

    @Override
    public void addLast(int data) {
        ListNode node=new ListNode(data);

        if(head==null){
            head=node;
        }else{
            ListNode cur=head;
            while(cur.next!=null){
                cur=cur.next;
            }
            cur.next=node;
        }

    }

    @Override
    public void addIndex (int index, int data) throws IndexException {
        ListNode node =new ListNode(data);
        if(index<0||index>size()){
            throw new IndexException("index位置不合法："+index);
        }
        if(head==null){
            head=node;
        }
        if(index==0){
            addFirst(data);
            return;
        }
        if(index==size()){
            addLast(data);
            return;
        }
        ListNode cur=findPrevIndex(index);
        node.next=cur.next;
        cur.next=node;

    }
    public ListNode findPrevIndex(int index){
        ListNode cur=head;
        int count=0;
        while (count<index-1){
            count++;
            cur=cur.next;
        }
        return cur;
    }

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

    @Override
    public void remove(int key) {
        if(head.val==key){
            head=head.next;
        }
        if(head==null){
            return;
        }
        ListNode cur=findPreKey(key);
        if(cur==null){
            return;//没有要删除的key值
        }
        ListNode del=cur.next;
        cur.next=del.next;
    }
    private ListNode findPreKey(int key){
        ListNode cur=head;
        while (cur.next!=null){
            if(cur.next.val==key){
                return cur;
            }else{
                cur=cur.next;
            }
        }
        return null;
    } public int size() {
        ListNode cur=head;
        int count=0;
        while (cur!=null){
            count++;
            cur=cur.next;
        }
        return count;
    }

    @Override
    public void clear() {
        head=null;
    }

    @Override
    public void display() {
        ListNode cur=head;
        while (cur!=null){
            System.out.print(cur.val+" ");
            cur=cur.next;
        }
        System.out.println();
    }

1.3IndexException类

用来处理任意位置插入时index的位置的不合法问题

public class IndexException extends RuntimeException{
    public IndexException(String message) {
        super(message);
    }

    public IndexException() {
    }
}

1.4Main类

用来测试的类

public class Main {
    public static void main(String[] args)  {
        MySingleList mySingleList=new MySingleList();
        //mySingleList.creatList();
        mySingleList.display();
        System.out.println(mySingleList.contains(23));
        System.out.println(mySingleList.size());
        mySingleList.addFirst(12);
        mySingleList.addFirst(23);
        mySingleList.addLast(34);
        mySingleList.addFirst(45);
        mySingleList.display();
        System.out.println(mySingleList.size());
        mySingleList.addIndex(4,66);
        mySingleList.display();
        mySingleList.clear();
    }
}

1.5运行截图

在这里插入图片描述

二、无头双向非循环链表

在javad的底层集合框架中LinkedList的底层逻辑就是无头双向非循环链表

2.无头双向非循环链表的实现

2.1List接口

用来存放即将实现的方法

package List;

public interface List {
    public void addFirst(int data);
    //尾插法
    public void addLast(int data);
    //任意位置插入,第一个数据节点为0号下标
    public void 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 display();
    public void clear();
}

2.2MyLinkedList类

无头双向链表的具体实现
1.无头双向链表的属性
比单向链表多了一个前驱节点prev,且记录了最后一个节点的地址last

 static class ListNode{
        int val;
        ListNode prev;
        ListNode next;
        public ListNode(int val) {
            this.val=val;
        }
    }

    ListNode head;
    ListNode last;

2.具体实现

package List;

public class MyLinkedList implements List{

   static class ListNode{
        int val;
        ListNode prev;
        ListNode next;
        public ListNode(int val) {
            this.val=val;
        }
    }
    ListNode head;
    ListNode last;
    @Override
    public void addFirst(int data) {
        ListNode node=new ListNode(data);
        if(head==null){
            head=node;
            last=node;
        }else {
            node.next=head;
            head.prev=node;
            head=node;
        }
    }

    @Override
    public void addLast(int data) {
        ListNode node=new ListNode(data);
        if(head==null){
            head=node;
            last=node;
        }else{
            last.next=node;
            node.prev=last;
            last=node;
        }

    }

    @Override
    public void addIndex(int index, int data) {
        ListNode node=new ListNode(data);
        checkIndex(index);
        if(index==0){
            addFirst(data);
            return;
        }
        if(index==size()){
            addLast(data);
            return;
        }
        ListNode cur=findIndex(index);
        node.next=cur;
        cur.prev.next=node;
        node.prev=cur.prev;
        cur.prev=node;
    }
    public void checkIndex(int index){
        if(index<0||index>size()){
            throw new IndexException("index位置不合法；"+index);
        }
    }
    public ListNode findIndex(int index){
        ListNode cur=head;
        while(index!=0){
            cur=cur.next;
            index--;
        }
        return cur;
    }

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

    @Override
    public void remove(int key) {
        ListNode cur = head;
        while (cur != null) {
            if (cur.val == key) {
                if (cur == head) {
                    head = head.next;
                    //判断是不是只有一个节点
                    if (head != null) {
                        head.prev = null;
                    } else {
                        last = null;
                    }
                } else {
                    //删除中间节点
                    if (cur.next != null) {
                        cur.next.prev=cur.prev;
                        cur.prev.next=cur.next;
                    }else{
                        //删除尾巴节点
                        cur.prev.next=cur.next;
                        last=last.prev;
                    }
                }
                return;
            }
            cur=cur.next;
        }
    }

    @Override
    public void removeAllKey(int key) {
        ListNode cur = head;
        while (cur != null) {
            if (cur.val == key) {
                if (cur == head) {
                    head = head.next;
                    //判断是不是只有一个节点
                    if (head != null) {
                        head.prev = null;
                    } else {
                        last = null;
                    }
                } else {
                    //删除中间节点
                    if (cur.next != null) {
                        cur.prev.next=cur.next;
                        cur.next.prev=cur.prev;
                    }else{
                        //删除尾巴节点
                        cur.prev.next=null;
                        last=last.prev;
                    }
                }

            }
            cur=cur.next;
        }

    }

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

    @Override
    public void display() {
        ListNode cur=head;
        while(cur!=null){
            System.out.println(cur.val+" ");
           cur=cur.next;
        }
        System.out.println();
    }

    @Override
    public void clear() {
        head=null;
        last=null;
    }
}

2.3IndexException类

用来记录插入位置index异常的类

package List;

public class IndexException extends RuntimeException{
    public IndexException() {
    }

    public IndexException(String message) {
        super(message);
    }
}

2.4Test类

用来测试方法

package List;

public class Test {
    public static void main(String[] args) {
            MyLinkedList myLinkedList=new MyLinkedList();
            myLinkedList.addFirst(12);
            myLinkedList.addFirst(23);
            myLinkedList.addFirst(34);
            myLinkedList.addFirst(45);
            myLinkedList.display();
            myLinkedList.addLast(56);
            myLinkedList.display();
            myLinkedList.addIndex(3,72);
            myLinkedList.display();
            myLinkedList.remove(72);
            myLinkedList.display();
    }
}

2.5运行截图

在这里插入图片描述

总结

以上就是今天要讲的内容，如果大家想多了解无头单向循环链表的面试题，可以去看我的另一个专栏—数据结构的应用，感谢大家的浏览！！！

心向小魔方
关注
  • 6
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用单向链表实现LinkedList
BiggerLee的博客
10-26 1792
单向链表是指节点中的指针域只有一个，指针域只能沿着同一个方向移动的链表。Java.util包中提供了LinkedList，此LinkedList是基于双向链表实现的。本文基于单向链表实现LinkedList中的某些方法，主要是学习使用下单向链表这种数据结构。
js单向链表的具体实现实例
10-27
js单向链表的具体实现实例，可以排序，增加，查找，删除的单向链表，需要的朋友可以参考一下
数据结构之--双链表MyLinkedList
apple3515的博客
03-24 124
　　双链表的手动实现中考虑三个类的实现： 1、MyLinkedList类本身的实现，包含到两端的链、表的大小以及一些方法。 2、Node节点，它可能是一个私有的内部嵌套类，这个类，嵌套在MyLinkedList的内部，数据域：data，前驱指针prev和后继指针next，以及合适的构造方法 3、LinkedListIterator类，该类抽象了位置的概念，是一个实现了Iterato...
Java数据结构 - 链表与MyLinkedList
Jiali的博客
12-23 227
链表是一种线性的数据结构，由有限的结点组成。其特点是结点的物理存储结构不一定连续，但逻辑顺序是连续的，通过链表中的引用链接次序实现。
链表的底层实现方式
huangshulang1234的博客
03-16 1002
链表的底层实现方式 链表在我们日常的开发过程中应该说是非常常见，做移动开发的更可以说是每天都在接触。比如MessageQueue，底层就是单链链表，各种网络框架用到的队列，底层用到的都是链表。而说到链表，就不得不提到另外一种数据结——集合。相信有一句话大家都听书过：集合更适合查询操作，链表更适合频繁的插入，删除操作。这究竟是为什么呢？今天我就从理论和代码的角度分析一下其中的原因。
[LeetCode] 实现链表
000
05-17 227
坚持内卷，pua自己，不是你死，就是我活。
链表的实现
周先生丶的博客
08-11 451
Java的List接口有两个比较常用的实现类，分别是ArrayList和LinkedList。关于它们的区别主要是ArrayList使用动态数组存储数据，而LinkedList使用相互链接的节点存储数据。关于它们的性能比较，具体要看进行的是什么操作，此处不赘述。 相关知识： 1、链式结构是一种数据结构，它使用对象引用变量来创建对象之间的链接。 2、链表由一些对象构成，其中每个对象指向了链表的...
【设计链表类MylinkedList】封装和信息隐藏的重要性
weixin_46554680的博客
07-06 200
通过这种方式，MyLinkedList 类提供了一个清晰、安全且易于使用的接口，同时保护了其内部实现的细节。这正是封装和信息隐藏原则的核心思想。当然，我很乐意为您详细解释这个概念，并通过一个具体的例子来说明封装和信息隐藏的重要性。
Java实现双向链表及其常规操作
qq_58284486的博客
03-16 2603
数据结构链表的学习结束了，我已经将重要的三种链表的简单实现整理并发布在了博客上，希望我的文章可以给有需要的朋友们带来帮助，也希望大家可以指出我存在的问题，共同进步，2022年冲刺大厂☺☺(*￣︶￣) 顺序表的简单实现：顺序表的简单实现 单链表的简单实现：单链表的简单实现 双向链表的定义 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表任意一个结点开始，都可以很方便的访问它的前驱结点和后继结点。 简易的双向链表模型 目.
Java双向链表倒置功能实现过程解析
weixin_51495453的博客
03-28 421
题目要求：Java实现一个双向链表的倒置功能（1->2->3 变成 3->2->1) 提交：代码、测试用例，希望可以写成一个Java小项目，可以看到单元测试部分 该题目的代码，已经放到了我的github上，地址为：https://github.com/jiashubing/alibaba-linkedlist-reversed.git 最关键的是自定义节点Node 和自定义双向链表MyLinkedList 两个类，倒置的方法放在自定义链表类里reversed() ，具体的说明都在代码
使用python实现链表操作
09-20
本文将详细介绍如何使用Python来实现链表的操作，包括单链表和双链表。 一、链表概念 链表由一系列节点构成，每个节点包含数据和指向下一个节点的引用。在Python中，我们可以通过定义一个类来模拟这种结构。单链表...
实验三 链表的实现和应用
01-05
1.编写算法，根据用户输入的字符数据...2.编写算法，实现在带有头结点的单链表中按序号查找的函数。 假设单链表中包含6个数据元素，测试数据： 1. 查找第0个. 2. 查找第1个. 3. 查找第2个. 4. 查找第6个. 5. 查找第7个.
整型链表实现
10-17
整型链表实现 C++。
数据结构—链式二叉树-C语言
h_number_1的博客
07-11 1010
上述内容，即是我个人对数据结构-链式二叉树-搜索二叉树-C语言的个人见解以及自我实现。若有大佬发现哪里有问题可以私信或评论指教一下我这个小萌新。
数据结构专项-字符串
qq_52241267的博客
07-16 235
面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子类。深拷贝和浅拷贝：浅拷贝实际上是复制了被拷贝对象的引用，也就是说浅拷贝的和被拷贝对象指向的是同一块内存空间，而深拷贝则是连同引用的对象也被拷贝，两者指向的是不同的内存空间。然后计算乘法，故之后是*，再计算加法，因此+要在6的前面，不然就是计算4*(x+3)+6了，故选D。中缀表达式中应该先计算x+3，因此后缀表达式中+应该出现在x和3的后面，排除BC。
【Java--数据结构】二叉树
最新发布
2301_80898480的博客
07-16 851
如有错误，欢迎指出~
常见排序算法总结
mydaily_的博客
07-16 521
大概是因为插入排序没预处理，极端情况可能让一个很小很右的数一直比比比比比，比到最开头，浪费比较次数。某种情况比计数排序好，因为数字，如果按照普通十进制理解，则只需准备10个不同数字的桶就好了！整体的quickSort函数swap后，再进行partition，划分三部分后，所以这种不基于比较的算法应用范围很局限，大部分情况下，不如之前的所有比较算法！前提得知道空间范围，比如人的年龄，正数[0-200]，否则内存爆炸！间隔分组，且分组间隔依次减半，每次分组后，每个组内排序都是插入排序。
数据结构第23节 线性搜索
hummhumm的专栏
07-12 379
线性搜索（Linear Search），也称为顺序搜索，是最基本的搜索算法之一。它的工作原理是通过遍历数组或列表中的每一个元素，直到找到目标值为止，或者遍历完所有元素后确定目标值不存在于列表中。线性搜索的时间复杂度为O(n)，其中n是列表中元素的数量。这是因为最坏情况下，你可能需要检查列表中的每一个元素才能找到目标值或确定它不在列表中。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值