【数据结构】模拟Java中的双向链表

已于 2023-11-08 10:43:11 修改
阅读量341 收藏
点赞数 3
分类专栏： Java 数据结构 文章标签： 链表 java 数据结构
于 2022-05-13 21:29:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39757593/article/details/124760264
版权
本文介绍了如何通过创建Node类和MyLinkedList类来实现一个简易的双向链表，并解决了原始版本的数据类型不安全问题，通过引入泛型实现元素类型的约束。关键步骤包括添加元素、获取元素数量和按索引获取元素。
摘要由CSDN通过智能技术生成

文章目录


**前言：**LinkedList底层是使用双向链表实现的，我们就来实现一个简易的MyLinkedList吧

分析：首先实现一个Node类用来存放所需存储的内容和上一个元素的地止和下一个元素的地址，再实现一个MyLinkedList类在里面定义Node属性first和last用来表示首尾节点，定义一个计数器用来表示添加次数，然后来实现add、size、get方法，具体实现过程请看0x001

0x000 Node类

由分析得，我们得创建一个Node类，可以封装三个属性，用来上一个节点地址、下一个节点地址和所需存储的内容，并实现toString方法

public class Node {
	//三个属性
	//上一个节点的地址
	private Node pre;
	//当前存入的元素
	private Object obj;
	//下一个节点的地址
	private Node next;
	public Node getPre() {
		return pre;
	}
    //封装节点的属性
	public void setPre(Node pre) {
		this.pre = pre;
	}
	public Object getObj() {
		return obj;
	}
	public void setObj(Object obj) {
		this.obj = obj;
	}
	public Node getNext() {
		return next;
	}
	public void setNext(Node next) {
		this.next = next;
	}
	@Override
	public String toString() {
		return "Node [pre=" + pre + ", obj=" + obj + ", next=" + next + "]";
	}
}

0x001 MyLinkedList类

我们实现了Node类后，就来实现MyLinkedList类吧。

  1. 定义属性和构造方法
public class MyLinkedList{
    //首尾元素
    Node first;
    Node last;
    //计时器
    int count=0;
    public MyLinkedList(){}
}
  1. 实现add方法：添加元素
public class MyLinkedList{
    //add方法添加元素
    public void add(Object obj){
        //如果first等于null，说明第一次添加元素
        if(first==null){
            //创建一个节点对象，并存入传入的元素
            Node n=new Node();
            //由于第一次添加，节点中的上一个节点使用null
            n.setPre(null);
            //在节点中存入元素
            n.setObj(obj);
            //由于第一次添加，节点中的下一个节点使用null
            n.setNext(null);
            //由于第一次添加，所以首尾节点（first和last）等于obj
            first=n;
            last=n;
        }else{
            //first不等于null，说明不是第一次添加元素，每次添加元素都一样了
            //创建节点对象
            Node n=new Node();
            //在节点中的上一个节点存入last
            n.setPre(last);
            //在节点中存入元素
            n.setObj(Obj);
            //在节点中的下一个节点存入null
            n.setNext(null);
            //在last中设置下一个节点为n
            last.setNext(n);
            //将n赋值给last
            last=n;
        }
        //添加元素的次数
        count++
    }
}

3.size方法：获取元素个数

public class MyLinkedList{
    public int size(){
        return count;
    }
}

4.get方法：下标从零开始获取元素数据

public class MyLinkedList{
    //下标从零开始获取元素数据
    public Object get(int index){
        Node n=first;
        //寻找下标为index的节点
        for(int i=0;i<index;i++){
            n=n.getNext();
        }
        return n.getObj();
    }
}

5.整理得：add方法、size方法、get方法构成简易的MyLinkedList类

public class MyLinkedList{
    //首尾元素
    Node first;
    Node last;
    //计时器
    int count=0;
    public MyLinkedList(){}
    //add方法添加元素
    public void add(Object obj){
        //如果first等于null，说明第一次添加元素
        if(first==null){
            //创建一个节点对象，并存入传入的元素
            Node n=new Node();
            //由于第一次添加，节点中的上一个节点使用null
            n.setPre(null);
            //在节点中存入元素
            n.setObj(obj);
            //由于第一次添加，节点中的下一个节点使用null
            n.setNext(null);
            //由于第一次添加，所以首尾节点（first和last）等于obj
            first=n;
            last=n;
        }else{
            //first不等于null，说明不是第一次添加元素，每次添加元素都一样了
            //创建节点对象
            Node n=new Node();
            //在节点中的上一个节点存入last
            n.setPre(last);
            //在节点中存入元素
            n.setObj(Obj);
            //在节点中的下一个节点存入null
            n.setNext(null);
            //在last中设置下一个节点为n
            last.setNext(n);
            //将n赋值给last
            last=n;
        }
        //添加元素的次数
        count++;
    }
    public int size(){
        return count;
    }
     //下标从零开始获取元素数据
    public Object get(int index){
        Node n=first;
        //寻找下标为index的节点
        for(int i=0;i<index;i++){
            n=n.getNext();
        }
        return n.getObj();
    }
}

0x002 Test类

public class Test{
	public static void main(String[] args) {
        //创建MyLinkedList对象
		MyLinkedList mll=new MyLinkedList();
        //添加元素
		mll.add("你好");
		mll.add("3Q");
		mll.add("zhoukali");
        //获取下标为2的元素
		System.out.println(mll.get(2));
        System.out.println("-----------------");
        //遍历MyLinkedList集合
		for(int i=0;i<mll.size();i++){
			System.out.println(mll.get(i));
		}
	}
}

运行效果：
在这里插入图片描述

0x003 解决数据类型安全问题

实现泛型版的MyLinkedList

**原因：**上面那种版本有一个明显的缺陷，数据类型不安全，不能固定一个相同的数据，为了约束数据类型我们可以实现一个泛型版的MyLinkedList

**改进：**我们把Node接口放在LinkedList类中，实现内部类方便管理

上代码：MyLinkedList类

public class MyLinkedList<E>{
	class Node {
		//三个属性
		//上一个元素的地址
		private Node pre;
		//当前存入的元素
		private E obj;
		//下一个元素的地址
		private Node next;
		public Node getPre() {
			return pre;
		}
		 //封装节点的属性
		public void setPre(Node pre) {
			this.pre = pre;
		}
		public E getObj() {
			return obj;
		}
		public void setObj(E obj) {
			this.obj = obj;
		}
		public Node getNext() {
			return next;
		}
		public void setNext(Node next) {
			this.next = next;
		}
		@Override
		public String toString() {
			return "Node [pre=" + pre + ", obj=" + obj + ", next=" + next + "]";
		}
	}
    //首尾元素
    Node first;
    Node last;
    //计时器
    int count=0;
    public MyLinkedList(){}
    //add方法添加元素
    public void add(E obj){
        //如果first等于null，说明第一次添加元素
        if(first==null){
            //创建一个节点对象，并存入传入的元素
            Node n=new Node();
            //由于第一次添加，节点中的上一个节点使用null
            n.setPre(null);
            //在节点中存入元素
            n.setObj(obj);
            //由于第一次添加，节点中的下一个节点使用null
            n.setNext(null);
            //由于第一次添加，所以首尾节点（first和last）等于obj
            first=n;
            last=n;
        }else{
            //first不等于null，说明不是第一次添加元素，每次添加元素都一样了
            //创建节点对象
            Node n=new Node();
            //在节点中的上一个节点存入last
            n.setPre(last);
            //在节点中存入元素
            n.setObj(obj);
            //在节点中的下一个节点存入null
            n.setNext(null);
            //在last中设置下一个节点为n
            last.setNext(n);
            //将n赋值给last
            last=n;
        }
        //添加元素的次数
        count++;
    }
    public int size(){
        return count;
    }
     //下标从零开始获取元素数据
    public E get(int index){
        Node n=first;
        //寻找下标为index的节点
        for(int i=0;i<index;i++){
            n=n.getNext();
        }
        return n.getObj();
    }
}

**测试一下：**Test类和运行结果

class Test{
	public static void main(String[] args) {
		MyLinkedList<String> mll=new MyLinkedList<String>();
		mll.add("你好");
		mll.add("3Q");
		mll.add("zhoukali");
		System.out.println(mll.get(2));
		System.out.println("-----------------");
		for(int i=0;i<mll.size();i++){
			System.out.println(mll.get(i));
		}
	}
}

在这里插入图片描述

数据结构之双向链表详解
小源_ 的博客
12-20 3655
本文着重讲解了LinkedList(无头双向单链表)的实现和LinkedList的使用。内附代码和图文分析，看完就会！
java - 数据结构，双向链表 - LinkedList
ryy1999的博客
12-03 1142
无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表 总结：    单向链表在删除一个节点的时候，需要借助前驱节点，才能删除。双向链表删除节点，不需要借助前驱节点 因为双向链表，它存储前驱和后驱的节点的地址，它都知道。 另外双向链表会多一个引用last，这个引用永远指向此时链表的尾巴节点 head就是永远指向双向链表的头节点。 2.2、实现一个类，来表示双向链表 实现LinkedList中的所有方法 通过这些方法就可以操作链表 得到链表的长度 查找是否包含关键字key
双向链表详细
weixin_45894950的博客
12-01 1338
无头双向链表 在Java的集合框架库中LinkedList底层实现就是无头双向循环链表 头插法 class Node { public int data;//数据 public Node next;//后继信息 引用类型不用初始化 null public Node prev;//前驱信息 //提供构造方法 public Node(int data) { this.data = data; } } public class MyLi
java实现双向链表（MyLinkedList）
weixin_64057226的博客
04-08 361
/需要判断是否在原来的链表中修改数据，如修改过则该迭代器就失效了，自然不能继续使用。//表示当前有指向元素，在迭代器删除的时候就可以成功。//需要判断是否在原来的链表中修改数据，如修改过则该迭代器就失效了，自然不能继续使用。//表示当前有指向元素，在迭代器删除的时候就可以成功。//删除元素方法，删除元素只需要将被删除元素的前指针和后指针给到后面的节点和前面的节点。//删除元素方法，删除元素只需要将被删除元素的前指针和后指针给到后面的节点和前面的节点。
java 双向链表_java集合类之LinkedList
weixin_39830588的博客
12-02 318
LinkedList简介LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。LinkedList 实现 List 接口，能对它进行队列操作。LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。...
简谈JAVA基础--双向链表(LinkedList)
Yu_uuuuu的博客
09-14 591
JAVA 双向链表实现 ,双向链表数据结构, 双向链表原理 ,LinkedList ,源码分析。
Java中集合（四）之LinkedList类的概述和实现（Java中的双向链表）
weixin_44918667的博客
04-25 1202
1.LinkedList容器类 LinkedList底层用双向链表实现的存储。特点：查询效率低，增删效率高，线程不安全。双向链表也叫双链表，是链表的一种，它的每个数据节点中都有两个指针，分别指向前一个节点和后一个节点。 所以，从双向链表中的任意一个节点开始，都可以很方便地找到所有节点。 1.1双向链表的介绍 class Node<E> { E item; Node<E> next; Node<E> prev.
Java模拟单链表和双端链表数据结构的实例讲解
09-02
总结起来，Java中的单链表和双端链表都是重要的数据结构，它们在内存中非连续存储数据，通过节点间的引用关系维持逻辑顺序。单链表只支持从前往后的遍历，而双端链表则允许双向遍历，提供更灵活的操作。在实际应用中...
java -数据结构，单向链表
ryy1999的博客
12-01 581
思考： 如何解决以上问题呢？下面给出了链表的结构来看看。
Java数据结构深入研究：双向链表与双向队列的高效应用
[Java数据结构深入研究：双向链表与双向队列的高效应用](http://images.cnitblog.com/i/497634/201403/241342164043381.jpg) # 1. 双向链表与双向队列的概述 在现代软件开发中，数据结构的选择对于程序的性能和可...
自己实现Java中基于双向链表的LinkedList
qq_37408976的博客
11-29 417
以下代码完全原创，如有纰漏或不足，请指出，多谢。 用于实现双向链表的节点对象，代码如下： package custom.node;public class Node<E> { //节点中的数据 private E e; //指向的下一个节点 private Node<E> next; //指向前一个的节点 private Node<E> prev
【数据结构与算法】4、双向链表（学习 jdk 的 LinkedList 部分源码）
m0_54189068的博客
06-27 817
双向链表（学习 jdk 的 LinkedList 部分源码）。🌱 动态数组：开辟、销毁内存空间的次数相对较少但可能造成内存空间浪费（可以通过缩容解决） 🌱 双向链表：开辟、销毁内存空间的次数相对较多（每次添加元素都会创建新的内存空间 ），但不会造成内存空间的浪费
【数据结构】Java实现双向链表
qq_53869058的博客
03-20 2156
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。
LinkedList底层结构 和 双向链表
weixin_46217811的博客
08-11 579
3.每个节点（Node对象），里面有维护了prev next item 三个属性，其中通过prev指向前一个，通过next 指向下一个节点。2.LinkedList中维护了两个属性，first和last 分别指向首节点和尾节点。4.所以LinkedList的元素的添加删除，不是通过数组完成的 相对来说效率较高。1.LinkedList底层维护了一个双向链表。2.添加三个对象，连接三个链表形成双向链表。1.LinkedList 是线程不安全的。2.ArrayList 也是线程不安全的。......
LinkedList双向链表的详细介绍
最新发布
qq_68754937的博客
07-11 1421
在Java源代码中，可以看出其常用的父接口有List接口，而List接口又继承于Collection接口，由此可以推断出：LinkedList类父接口为List，祖宗接口为Collection。5.根据指定索引删除元素public E remove(int index)，首先对index索引进行校验，校验通过后调用unlink(Node x)方法，判断要删除的元素所处的位置，进行不同的操作，最后把要删除的元素清空，减小集合大小，增加修改计数器。
Java——模拟实现LinkedList（双向链表）
华墨1024的博客
10-27 236
模拟实现LinkedList双向链表，加深自己的理解
【Java 集合】LinkedList
LCN29的博客
11-26 1212
** 当前节点的内容 */E item;/** 下一个节点 *//** 上一个节点 */// 当前节点的数据 = element// 当前节点的后置节点 = next// 当前节点的前置节点 = prevNode 节点中除了指向下一个节点的 next, 还包含指向上一个节点的 prev, 所以 LinkedList 是一个双向的链表。
Java集合类——LinkedList（单链表及双链表）
小小码农
12-29 1157
Java集合类——LinkedList（单链表及双链表）
自定义实现LinkedList
天堂的博客
12-24 3874
上一篇文章自定义实现了ArrayList集合，现在则自定义实现LinkedList。学过集合的读者都知道，ArrayList的底层实现是用数组实现，而LinkedList的实现则是用链表实现。那么什么是链表呢？其实可以把它比喻成一串珠子，珠子通过线来串连起来。要想找到中间的珠子，就只能通过第一个珠子或者最后一个珠子，一个一个的找下去，直到找到所要的珠子。 链表分为单向链表和双向链表，单向
JAVA实现双向链表增删功能详解
在Java编程中，双向链表是一种数据结构，它允许在链表的两个方向上进行遍历。与单链表不同，双向链表的每个节点不仅包含数据，还包含两个指针，一个指向下一个节点（next），另一个指向前一个节点（prev）。这种设计...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值