手动实现LinkedList

最新推荐文章于 2023-10-21 10:04:41 发布
最新推荐文章于 2023-10-21 10:04:41 发布
阅读量111 收藏
点赞数
分类专栏： Java基础 文章标签： LinkedList 双向链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37840807/article/details/97611366
版权

链表是由一系列结点（node）组成的，结点可以在运行时动态生成。链表有单向链表和双向链表两种结构，单向链表的每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。双向链表的每个结点包括三个部分：存储数据元素的数据域、存储下一个结点地址的指针域和存储上一个结点地址的指针域。

一、单向链表

单链表的特点是：节点的链接方向是单向的；相对于数组来说，单链表的的随机访问速度较慢，但是单链表删除/添加数据的效率很高。

在这里插入图片描述

单链表删除结点

在这里插入图片描述

单链表增加结点

在这里插入图片描述

二、双向链表

双向链表(双链表)是链表的一种。和单链表一样，双链表也是由节点组成，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。
在这里插入图片描述

双向链表删除结点

在这里插入图片描述

双向链表添加结点

在这里插入图片描述

三、手动实现LinkedList

java中的LinkedList是双向链表
在这里插入图片描述

1.定义结点

在这里插入图片描述

package cn.GTMStudio.MyConnection;

public class Node {
    Node previous;//上一个结点
    Node next;//下一个结点
    Object element;//元素数据

    public Node(Node previous, Node next, Object element) {
        this.previous = previous;
        this.next = next;
        this.element = element;
    }

    public Node(Object element) {
        this.element = element;
    }
}

2.增加add方法

在这里插入图片描述

package cn.GTMStudio.MyConnection;

/**
 * 添加add方法
 * @author henrly 
 */
@SuppressWarnings("all")
public class GTMLinkedList01 {
    private Node first;//头指针
    private Node last;//尾指针
    private int size;//结点数

    //
    public void add(Object obj) {
        Node node = new Node(obj);
        if (first == null) {
            //第一次调用时
            first = node;
            last = node;
        } else {
            node.previous = last;
            node.next = null;
            last.next = node;
            last = node;
        }
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        Node temp = first;
        while (temp != null) {
            sb.append(temp.element + ",");
            temp = temp.next;
        }
        sb.setCharAt(sb.length() - 1, ']');
        return sb.toString();
    }

    public static void main(String[] args) {
        GTMLinkedList01 list = new GTMLinkedList01();
        list.add("a");
        list.add("b");
        list.add("c");
        System.out.println(list);

    }

}

3.增加get方法

链表的随机访问速度很慢，需要依次遍历，这里先判断索引与链表长度的一半，若小于则从头节点开始遍历，若大于则从尾结点开始遍历，这样就大大提高了效率。

 Node temp = null;
        if (index < (size >> 1)) {
            temp = first;
            for (int i = 0; i < index; i++) {
                temp = temp.next;
            }
        } else {
            temp = last;
            for (int i = size - 1; i > index; i--) {
                temp = temp.previous;

            }
        }

package cn.GTMStudio.MyConnection;

/**
 * 自定义一个链表
 * 增加get方法
 *
 * @author henrly
 */
@SuppressWarnings("all")
public class GTMLinkedList02 {
    private Node first;
    private Node last;
    private int size;

    public Object get(int index) {

        if (index < 0 || index > size - 1) {
            throw new RuntimeException("索引数字不合法：" + index);
        }
        Node temp = null;
        if (index < (size >> 1)) {
            temp = first;
            for (int i = 0; i < index; i++) {
                temp = temp.next;
            }
        } else {
            temp = last;
            for (int i = size - 1; i > index; i--) {
                temp = temp.previous;

            }
        }
        return temp.element;
    }

    //
    public void add(Object obj) {
        Node node = new Node(obj);
        if (first == null) {
            //第一次调用时
            first = node;
            last = node;
        } else {
            node.previous = last;
            node.next = null;
            last.next = node;
            last = node;
        }
        size++;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        Node temp = first;
        while (temp != null) {
            sb.append(temp.element + ",");
            temp = temp.next;
        }
        sb.setCharAt(sb.length() - 1, ']');
        return sb.toString();
    }

    public static void main(String[] args) {
        GTMLinkedList02 list = new GTMLinkedList02();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");
        System.out.println(list);
        System.out.println(list.get(1));

    }

}

4.增加remove方法

package cn.GTMStudio.MyConnection;

/**
 * 自定义一个链表
 * 增加remove()方法
 *
 * @author henrly
 */
@SuppressWarnings("all")
public class GTMLinkedList03 {
    private Node first;
    private Node last;
    private int size;

    public void remove(int index) {
        Node temp = getNode(index);
        if (temp != null) {
            Node up = temp.previous;
            Node down = temp.next;
            if (up != null) {
                up.next = down;
            }
            if (down != null) {
                down.previous = up;
            }
            if (index == 0) {
                first = down;
            }
            if (index == size - 1) {
                last = up;
            }
            size--;

        }

    }

    public Object get(int index) {

        Node temp = getNode(index);
        return temp != null ? temp.element : null;
    }

    public Node getNode(int index) {
        if (index < 0 || index > size - 1) {
            throw new RuntimeException("索引数字不合法：" + index);
        }
        Node temp = null;
        if (index < (size >> 1)) {
            temp = first;
            for (int i = 0; i < index; i++) {
                temp = temp.next;
            }
        } else {
            temp = last;
            for (int i = size - 1; i > index; i--) {
                temp = temp.previous;

            }
        }
        return temp;
    }


    //
    public void add(Object obj) {
        Node node = new Node(obj);
        if (first == null) {
            //第一次调用时
            first = node;
            last = node;
        } else {
            node.previous = last;
            node.next = null;
            last.next = node;
            last = node;
        }
        size++;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        Node temp = first;
        while (temp != null) {
            sb.append(temp.element + ",");
            temp = temp.next;
        }
        sb.setCharAt(sb.length() - 1, ']');
        return sb.toString();
    }

    public static void main(String[] args) {
        GTMLinkedList03 list = new GTMLinkedList03();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");
        System.out.println(list);
        list.remove(2);
        System.out.println(list);
        list.remove(0);
        System.out.println(list);


    }

}

5. 增加插入方法

package cn.GTMStudio.MyConnection;

/**
 * 自定义一个链表
 * 增加插入方法
 *
 * @author henrly
 */
@SuppressWarnings("all")
public class GTMLinkedList04 {
    private Node first;
    private Node last;
    private int size;

    public void add(int index,Object obj){
        Node newNode=new Node(obj);
        Node temp=getNode(index);
        if(temp!=null){
            Node up=temp.previous;
            up.next=newNode;
            newNode.previous=up;
            newNode.next=temp;
            temp.previous=newNode;
        }

    }
    public void remove(int index) {
        Node temp = getNode(index);
        if (temp != null) {
            Node up = temp.previous;
            Node down = temp.next;
            if (up != null) {
                up.next = down;
            }
            if (down != null) {
                down.previous = up;
            }
            if (index == 0) {
                first = down;
            }
            if (index == size - 1) {
                last = up;
            }
            size--;

        }

    }

    public Object get(int index) {

        Node temp = getNode(index);
        return temp != null ? temp.element : null;
    }

    public Node getNode(int index) {
        if (index < 0 || index > size - 1) {
            throw new RuntimeException("索引数字不合法：" + index);
        }
        Node temp = null;
        if (index < (size >> 1)) {
            temp = first;
            for (int i = 0; i < index; i++) {
                temp = temp.next;
            }
        } else {
            temp = last;
            for (int i = size - 1; i > index; i--) {
                temp = temp.previous;

            }
        }
        return temp;
    }


    //
    public void add(Object obj) {
        Node node = new Node(obj);
        if (first == null) {
            //第一次调用时
            first = node;
            last = node;
        } else {
            node.previous = last;
            node.next = null;
            last.next = node;
            last = node;
        }
        size++;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        Node temp = first;
        while (temp != null) {
            sb.append(temp.element + ",");
            temp = temp.next;
        }
        sb.setCharAt(sb.length() - 1, ']');
        return sb.toString();
    }

    public static void main(String[] args) {
        GTMLinkedList04 list = new GTMLinkedList04();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");
        System.out.println(list);
       list.add(3,"hhh");
        System.out.println(list);


    }

}

6.增加泛型

package cn.GTMStudio.MyConnection;

/**
 * 自定义一个链表
 * 增加小的封装、增加泛型
 *
 * @author henrly
 */
@SuppressWarnings("all")
public class GTMLinkedList05<E> {
    private Node first;
    private Node last;
    private int size;

    public void add(int index,E element){
        Node newNode=new Node(element);
        Node temp=getNode(index);
        if(temp!=null){
            Node up=temp.previous;
            up.next=newNode;
            newNode.previous=up;
            newNode.next=temp;
            temp.previous=newNode;
        }

    }
    public void remove(int index) {
        Node temp = getNode(index);
        if (temp != null) {
            Node up = temp.previous;
            Node down = temp.next;
            if (up != null) {
                up.next = down;
            }
            if (down != null) {
                down.previous = up;
            }
            if (index == 0) {
                first = down;
            }
            if (index == size - 1) {
                last = up;
            }
            size--;

        }

    }

    public Object get(int index) {

        Node temp = getNode(index);
        return temp != null ? (E)temp.element : null;
    }

    private Node getNode(int index) {
        if (index < 0 || index > size - 1) {
            throw new RuntimeException("索引数字不合法：" + index);
        }
        Node temp = null;
        if (index < (size >> 1)) {
            temp = first;
            for (int i = 0; i < index; i++) {
                temp = temp.next;
            }
        } else {
            temp = last;
            for (int i = size - 1; i > index; i--) {
                temp = temp.previous;

            }
        }
        return temp;
    }


    //
    public void add(E element) {
        Node node = new Node(element);
        if (first == null) {
            //第一次调用时
            first = node;
            last = node;
        } else {
            node.previous = last;
            node.next = null;
            last.next = node;
            last = node;
        }
        size++;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        Node temp = first;
        while (temp != null) {
            sb.append(temp.element + ",");
            temp = temp.next;
        }
        sb.setCharAt(sb.length() - 1, ']');
        return sb.toString();
    }

    public static void main(String[] args) {
        GTMLinkedList05<String > list = new GTMLinkedList05<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");
        System.out.println(list);
        list.add(3,"hhh");
        System.out.println(list);


    }

}
HenrlyLiu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何实现Java中一个简单的LinkedList
08-31
LinkedList与ArrayList都是List接口的具体实现类。下面将介绍如何实现一个简单的LinkedList，具有很好的参考价值，下面跟着小编一起来看下吧
C++手动实现单链表类
07-15
C++手动实现带头结点的单链表类，测试环境为Visual Studio 2010
LinkedList源码详解（常用方法源码分析）及 手动实现LinkedList
Jewel’s blog
03-07 256
一、LinkedList详解 特点： 元素可以重复 元素可以为null 数据插入有序 常用方法介绍： JDK1.8源码分析：
LinkedList的手动实现
蜜蜂采蜜
06-19 612
上一篇我们讲解了Collection接口之List子接口中的ArrayList、Vector以及Stack的实现类，由于比较简单，不在赘述，下来我们讲解List接口之LinkedList实现类 （1）LinkedList类本质上是一个双向链表，也是单向队列，双向队列，栈的实现类； （2）LinkedList类实现了单向队列，双向队列的接口，自身也提供了栈操作的方法，链表操作的方法； （3）L
手工实现LinkedList
MADE_哒哒
01-16 237
https://blog.csdn.net/qq_40301026/article/details/86773133 参照其底层代码，按照自己的理解实现了LinkedList的一些基本功能。 如果对c和c++指针了解一下，理解起来非常快。 package cn.liu.MyLinkedList; //结点 public class Node { Node prevoius;//上一个节...
Java中LinkedList详解和使用示例_动力节点Java学院整理
08-30
2. **非同步**：LinkedList不是线程安全的，如果在多线程环境下使用，需要手动进行同步控制。 3. **序列化**：LinkedList实现了Serializable接口，支持序列化操作。 4. **效率**：由于使用链表结构，LinkedList在...
Java中ArrayList和LinkedList的遍历与性能分析
09-01
在Java编程中，ArrayList和LinkedList是两种常用的列表（List）实现，它们各有特点，并且在遍历和性能上有显著的差异。以下是对这两种数据结构及其遍历方式的详细分析： 1. **ArrayList**：ArrayList是基于动态数组...
ArrayList LinkedList Vector性能对比
03-29
2. **线程安全**：ArrayList和LinkedList不是线程安全的，如果在多线程环境中使用，需要手动添加同步机制，或者选择Vector。 3. **内存消耗**：LinkedList比ArrayList和Vector占用更多的内存，因为它需要存储额外的...
go-linkedlist:静态类型的链表
03-17
"go-linkedlist"项目就是针对这种需求提供的一种静态类型的链表实现。 在Go语言中，"静态类型"指的是在编译时就能确定变量的数据类型。与动态类型不同，静态类型可以提供更好的类型安全性和性能。在"go-linkedlist...
手动实现一个LinkedList链表
岁月流逝
08-24 259
前言：一切从简，本链表存放int数据，不适用泛型 一、实现思路 （1）void add()：对链表进行尾插 （2）int get(int index)：依据传入的索引，找到对应元素 （3）int remove(int index)：依据传入的索引，删除对应元素，并返回被删除的元素值 （4）int set(int index, int val)：依据传入的索引和值，将对应元素的值改为传入值，并返回修改前的值 （5）int size()：返回容器中的元素个数 二、实现步骤 1）创建一个链表的容器 先定义两个指针
JAVA 手动实现LinkedList
小城我家
12-04 302
### JAVA 手动实现LinkedList节点package com.ghg.data_structure.link;public class Node<T> { /** * 数据 */ public T data; /** * 前一个 */ public Node pre; /** * 后一个
Java手动实现LinkedList（底层实现）
qiaomm的个人博客
02-07 405
以下是是Java手动实现LinkedList的代码例子： 功能介绍： 自定义一个链表； 添加 和删除节点 ； 插入节点 ； 增加小的封装； 增加泛型； 具体代码如下： 新建两个class，一个是SxtLinkedList，一个是Node。 SxtLinkedList类的代码如下： /** * 自定义一个链表 添加 删除节点 插入节点 增加小的封装，增加泛型 * * @author Adm...
java手动实现双向链表LinkedList
小范的博客
01-12 825
一、LinkedList原理介绍 LinkedList是java中重要的List集合，其内部是一个双向链的数据结构。插入和删除的效率比ArrayList高,之前手动实现的ArrayList，因为插入和删除没有数组的复制工作，如果想在下标为index位置插入元素则通过从头部或者尾部开始查找，找到index原始位置的元素，则修改原始位置index元素的Node中的上一个元素，以及元素index元素前
LinkedList的简单实现（手写）
L-Study
07-04 3440
LinkedList的底层是基于链表实现的，所以查询慢，增删改快，但是线程不安全，效率较高。代码：/** * 1.LinkedList的简单实现 * 2.后续有时间会逐步添加方法 * 3.实现的方法有： * void add(Object obj) * void add(int index,Object obj) *
手动基本实现Linkedlist集合（二）
CleanCode
12-04 168
上一篇文章讲了Linkedlist的add(),get(),toString,没有看的朋友可以去看一下：手动基本实现Linkedlist集合（一），开始后面的实现 1.添加remove(int index)，移除节点方法 解释：就是讲一个节点从链表中删除 实现：改变要删除节点的前后节点指向问题 原链表格式 删除进行的操作 简单陈述：让它前面的next，指向它的后面；让它后面的p...
数据结构链表看这一篇就够了 Link List 手写实现（图文解释，附常见面试题）
最新发布
m0_65819602的博客
10-21 1140
链表的数据结构通过链的连接方式，提供了可以不需要扩容空间就更高效的插入和删除元素的操作，在适合的场景下它是一种非常方便的数据结构。在“双向链表”中，除了下一个节点链接之外，每个节点还包含指向序列中“前一个”节点的第二个链接字段。在计算机科学中，链表是数据元素的线性集合，元素的线性顺序不是由它们在内存中的物理地址给出的。在最简单的链表结构下，每个节点由数据和指针（存放指向下一个节点的指针）两部分组成，这种数据结构允许在迭代时有效地从序列中的任何位置插入或删除元素。可以对单链表执行的操作包括插入、删除和遍历。
手动实现LinkedList ，get查询，节点遍历 (2)
weixin_40072979的博客
09-28 539
  package com.jianshun; public class Node { Node previous; //上一个节点 Node next; //下一个节点 Object element; //元素数据 public Node(Node previous, Node next, Object element) { super(); this.previou...
linkedlist手动操作来实现有序性
04-16
好的，我可以回答这个问题。您可以手动操作链表来实现有序性，可以通过以下步骤实现： 1. 创建一个链表头节点。 2. 插入节点时，从链表头开始遍历，如果需要插入的值小于当前节点的值，则在当前节点之前插入；如果大于或等于当前节点的值，则继续遍历下一个节点，直到找到插入位置为止。 3. 删除节点时，同样从链表头开始遍历，找到需要删除的节点，并将其从链表中删除。 通过手动操作链表，可以实现链表的有序性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值