链表的实现（LinkedList）

最新推荐文章于 2022-11-10 00:38:13 发布
最新推荐文章于 2022-11-10 00:38:13 发布
阅读量123 收藏 1
点赞数 2
分类专栏： 算法与数据结构 文章标签： java 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaocl123/article/details/116784210
版权

List 接口

// 将ArrayList 和 LinkedList 的共性方法定义一个接口，保证体系的完整性
public interface List<E>{

    // 三个基本方法
    int size();
    boolean isEmpty();

    // 增
    void add(E element);
    void add(int index,E element);

    // 删
    E remove(int index);

    // 改
    E set(int index,E element);

    // 查
    boolean contains(E element);

    // 根索引获取
    E get(int index);

    // 根据内容获取索引
    int valueof(E element);

    // 清空
    void clear();

    String toString();
}

AbstractList 抽象类

public abstract class AbstractList<E> implements List<E> {

    protected int size; // 子类也可以访问,private 子类不能访问

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean contains(E element) {
        return valueof(element) != -1;
    }

    @Override
    public void add(E element) {
        add(size,element);
    }
}

单向链表

public class MyLinkedList<E> extends AbstractList<E> {

    // 头节点
    private Node<E> first;

    // 定义节点的类,定义私有，内部类
    private static class Node<E> {
        // 成员变量
        // 下一个内存地址，存储的数据
        Node<E> next;
        E element;

        // 构造方法
        public Node(Node next, E element) {
            this.next = next;
            this.element = element;
        }
    }

    @Override
    public void add(int index, E element) {
        // 判断索引
        checkPositionIndex(index);
        if (index == 0) {
            first = new Node<>(first, element);
        } else {
            Node<E> pre = node(index - 1);
            Node<E> next = pre.next;
            pre.next = new Node<>(next, element);
        }
        size++;
    }

    private void checkPositionIndex(int index) {
        if (!isPositionIndex(index)) {
            throw new IndexOutOfBoundsException("IndexOutOfBoundsException：index " + index + ", size " + size);
        }
    }

    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }

    @Override
    public E remove(int index) {

        // 判断索引
        checkElementIndex(index);
        Node<E> oldNode= first;
        if(index==0){
            first=first.next;
            size--;
            return oldNode.element;
        }else {
            Node<E> pre = node(index - 1);
            oldNode = pre.next;
            pre.next = oldNode.next;
            size--;
            return oldNode.element;
        }
    }

    @Override
    public E set(int index, E element) {
        // 首先判断index是否合法
        // 进行修改
        checkElementIndex(index);
        Node<E> node = node(index);
        E oldElement = node.element;
        node.element = element;
        return oldElement;
    }

    @Override
    public E get(int index) {
        // 首先判断index是否合法
        checkElementIndex(index);
        return node(index).element;
    }

    private void checkElementIndex(int index) {
        if (!isElementIndex(index)) {
            throw new IndexOutOfBoundsException("IndexOutOfBoundsException：index " + index + ", size " + size);
        }
    }

    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }

    private Node<E> node(int index) {
        Node<E> x = first;
        for (int i = 0; i < index; i++) {
            x = x.next;
        }
        return x;
    }

    @Override
    public int valueof(E element) {
        Node x = first;
        int index = 0;
        // 要考虑到 null 的情况
        if (element == null) {
            while (x != null)
                if (x.element == element) return index;
            x = x.next;
            index++;
        } else {
            while (x != null) {
                if (element.equals(x.element)) return index;
                x = x.next;
                index++;
            }
        }
        return -1;
    }

    @Override
    public void clear() {
        // help gc
        size = 0;
        first = null;
        // 可达性算法：JVM
        // 判断对象是否是一个垃圾的标准
        // 选择一个节点作为GC-ROOTS顶点，其他对象或者引用指向GC-ROOTS顶点，如果这些对象能够到达GC-ROOTS顶点，就不是垃圾，反之则是
    }

    @Override
    public String toString() {
        if (size == 0) {
            return "[]";
        }

        // 利用 StringBuilder 的对象进行输出拼接
        StringBuilder sb = new StringBuilder();
        sb.append("[");

        Node x = first;
        for (Node i = x; i!=null ; i=i.next) {
            sb.append(i.element);
            if(i.next==null){
                sb.append("]");
            }
            sb.append(", ");
        }

        return sb.toString();
    }
}

双向链表

public class MyLinkedList2<E> extends AbstractList<E> {

    // 头节点
    private Node<E> first;
    private Node<E> last;

    // 定义节点的类,定义私有，内部类
    private static class Node<E> {
        // 成员变量
        // 下一个内存地址，存储的数据
        Node<E> pre;
        Node<E> next;
        E element;

        // 构造方法
        public Node(Node pre, Node next, E element) {
            this.pre = pre;
            this.next = next;
            this.element = element;
        }
    }

    @Override
    public void add(int index, E element) {
        // 判断索引
        checkPositionIndex(index);

        // 添加到末尾或者没有元素的时候
        if (index == size) {
            linkLast(element);
        } else {
            linkBefore(element, node(index));
        }
        size++;

    }

    private void linkLast(E element) {
        Node<E> l = last;
        Node<E> newNode = new Node<>(l, null, element);
        last = newNode;
        if (l == null) {
            first = newNode;
        } else {
            l.next = newNode;
        }

    }

    private void linkBefore(E element, Node<E> node) {
        Node<E> pre = node.pre;
        Node<E> newNode = new Node<>(pre, node, element);
        node.pre = newNode;
        if (pre == null) {
            first = newNode;
        } else {
            pre.next = newNode;
        }
    }

    private void checkPositionIndex(int index) {
        if (!isPositionIndex(index)) {
            throw new IndexOutOfBoundsException("IndexOutOfBoundsException：index " + index + ", size " + size);
        }
    }

    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }

    @Override
    public E remove(int index) {

        // 判断索引
        checkElementIndex(index);

        Node<E> node = node(index);
        Node<E> pre = node.pre;
        Node<E> next = node.next;

        if(pre==null){
            next.pre=null;
            first=next;
        }else {
            pre.next=next;
        }

        if(next==null){
            last=pre;
        }else {
            next.pre=pre;
        }

        size--;
        return node.element;
    }

    @Override
    public E set(int index, E element) {
        // 首先判断index是否合法
        // 进行修改
        checkElementIndex(index);
        Node<E> node = node(index);
        E oldElement = node.element;
        node.element = element;
        return oldElement;
    }

    @Override
    public E get(int index) {
        // 首先判断index是否合法
        checkElementIndex(index);
        return node(index).element;
    }

    private void checkElementIndex(int index) {
        if (!isElementIndex(index)) {
            throw new IndexOutOfBoundsException("IndexOutOfBoundsException：index " + index + ", size " + size);
        }
    }

    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }

    private Node<E> node(int index) {
        Node<E> x = first;
        // 首先判断 index 与 size/2 的大小进行比较
        if (index <= size >> 1) {
            for (int i = 0; i < index; i++) {
                x = x.next;
            }

        } else {
            x = last;
            for (int i = size - 1; i > index; i--) {
                x = x.pre;
            }
        }
        return x;
    }

    @Override
    public int valueof(E element) {
        Node x = first;
        int index = 0;
        // 要考虑到 null 的情况
        if (element == null) {
            while (x != null)
                if (x.element == element) return index;
            x = x.next;
            index++;
        } else {
            while (x != null) {
                if (element.equals(x.element)) return index;
                x = x.next;
                index++;
            }
        }
        return -1;
    }

    @Override
    public void clear() {
        // help gc
        size = 0;
        first = null;
        last = null;
        // 可达性算法：JVM
        // 判断对象是否是一个垃圾的标准
        // 选择一个节点作为GC-ROOTS顶点，其他对象或者引用指向GC-ROOTS顶点，如果这些对象能够到达GC-ROOTS顶点，就不是垃圾，反之则是
    }

    @Override
    public String toString() {
        if (size == 0) {
            return "[]";
        }

        // 利用 StringBuilder 的对象进行输出拼接
        StringBuilder sb = new StringBuilder();
        sb.append("[");

        Node x = first;
        for (Node i = x; i != null; i = i.next) {
            sb.append(i.element);
            if (i.next == null) {
                sb.append("]");
            }
            sb.append(", ");
        }

        return sb.toString();
    }
}
肖大仙~
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
链表设计与Java实现，手写LinkedList这也太清楚了吧
JavaMonsterr的博客
07-04 146
在谈链表之前，我们先谈谈我们平常编程会遇到的很常见的一个问题。如果在编程的时候，某个变量在后续编程中仍需使用，我们可以用一个局部变量来保存该值，除此之外一个更加常用的方法就是使用容器了。那什么是 容器 呢？从字面上来说就是用来装某个东西的，比如我们的杯子，就是容器。在程序设计当中我们最常见的容器就是数组了，他可以存我们想保存的东西。在编程当中我们最常见的容器如下：今天要谈到的链表在Java的 和C++的 当中就有使用到。那什么是链表呢？链表是由一个一个的节点组成的，每个节点包含两个字段，其中一个字段da
用链表实现LinkedList
来杯咖啡吗的博客
09-24 79
public class myLinkedList implements Iterable { private int thesize; //存储当前链表的长度 private int modcount = 0; private Node beginMarker; //链表的头节点，其next指向链表的第一个节点 private Node endMarker; //链表的尾节点，其prev指向链表的最后一个节点 public myLinkedLi.
链表MyLinkedList的代码实现
web教程
07-05 256
一、需要实现的几个API 二、构造函数 链表为空时：head tail 2. getNode(index) 3. 检查索引是否合法 四、增删查改 1. 增 链表头部插入节点x 链表尾部插入节点x 在索引index处插入节点x 2. 删 删除第一个节点 删除最后一个节点 删除索引index对应的节点 3. 查 查找第一个元素 查找最后一个元素 查找索引为index的元素 4. 改 ...
Java 数据结构与算法笔记 003 链表实现列表
薯叶
03-27 545
简介：笔记 链表实现列表 用链表来实现列表 链表 链表是有序的列表，其特点如下： 链表是以节点的方式储存的 链表的每一个节点内都包含两大部分的内容，一个内容存储数据，一个内容存储下一个节点的位置 链表的节点在内存空间中不一定是连续存储的（但在逻辑结构上是连续存储的） 链表的分类 带头节点的链表 头结点 头结点不存放数据 头结点的作用是表示单链表的头（相当于火车头的作用） 不带头节点的链表 单链表 一个示例：使用带有头节点的单向链表实现水浒人物排行榜的管理 要实现上面的
【久远讲算法】链表——实现无序列表
nruuu的博客
10-30 588
你好，我是久远，上周开始我们算是正式入门了数据结构，进行了数组的讲解。 我们现在来总结回顾一下数组的知识。 数组是什么？ 是由相同类型的元素的集合所组成的数据结构，分配一块连续的内存来存储。利用元素的索引（index）可以计算出该元素对应的存储地址。 数组的储存类型 顺序存储：数组在内存中的顺序存储，具体是什么样子呢？ 内存是由一个个连续的内存单元组成的，每一个内存单元都有自己的地址。在这些内存单元中，有些被他数据占用了，有些是空闲的。 数组中的每一个元素，都存储在小小的内存单元中，并且元素之间紧密
C#双向链表LinkedList排序实现方法
09-03
在C#编程语言中，双向链表（LinkedList）是一种数据结构，它允许在列表的任一侧进行插入和删除操作，而不像数组那样需要移动大量元素。LinkedList类是.NET框架提供的，它包含两个指针：一个指向前一个节点，另一个...
C#练习 阶段练习：实现链表（LinkedList）
11-15
阶段练习：实现链表（LinkedList） 简介：写一个链表的数据结构，要求实现IList接口。 具体要求： 1、 使用代码规范。 2、 至少对IList中的Add，Remove，Insert，Indexer，IEnumerator进行单元测试。 3、 对上述每个...
linkedList:javascript中的链表实现
07-03
链表javascript中的链表实现请通过 mocha 测试文档npm 测试链表堆栈： ✓ allows adding elements through array inside constructor ✓ allows adding elements ✓ allows taking out elements at top ✓ has an ...
linkedlist:ADSB 链表实现
06-26
此外，由于LinkedList实现了List接口，所以它还支持基于索引的操作，例如get(int index)和set(int index, E element)。 在实现ADSB链表时，可能需要对LinkedList进行扩展或自定义，以满足特定的业务逻辑。例如，...
LinkedList---链表各种方法的实现
Gavin_W_的博客
09-06 183
public class ListExer2 { public static void main(String[] args) { LinkList list = new LinkList(); list.add(&quot;a&quot;); list.add(&quot;b&quot;); list.add(&quot;c&quot;); // list.add(0..
JAVA实现LinkedList链表
ven13的博客
02-26 367
package com.github.Ven13.coding2017.basic;//MyLinkedList功能类： public class MyLinkedList extends MyAbstractList {private Node first, last;private static class Node { Object element; Node next;
手动实现一个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集合链表操作方法
热带雨林-的博客
05-15 1139
package com.javabase.p1; import java.util.Iterator; import java.util.LinkedList; public class Testlinklist { public static void main(String[] args) { //LinkedList链表操作方法 LinkedList<In...
LinkedList 链表 Java 实现
CodeDoraemon的博客
09-13 137
1、定义的接口如下： package com.luobin.力扣数据结构练习题目.接口的定义; /** * @author LuoBin * @version 1.0 * @date 2021/9/3 3:51 下午 */ // 接口中存在的东西放上去之后，默认就是公共的，不需要加上 public public interface List<E> { int ELEMENT_NOT_FOUND = -1; void clear(); boolean isE
LinkedList<E>泛型类的遍历，排序和查找
gh6267的博客
09-09 2248
遍历 链表对象可以使用iterator()方法获取一个Iterator对象，该对象就是针对当前链表的迭代器，我们使用这个迭代器来遍历import java.io.OutputStream; import java.io.IOException; import java.io.InputStream; import java.io.PrintWriter; import java.util.Stri
链表-----Java中LinkedList类的实现
分享点点滴滴的知识~
11-10 637
链表 LinkedList
栈和队列之LinekedList(双端队列)
码莎拉蒂
12-08 2001
介绍： （deque，全名double-ended queue）是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。 双端队列是限定插入和删除操作在表的两端进行的线性表。这两端分别称做端点1和端点2（如下图(a)所示）。也可像栈一样，可以用一个铁道转轨网络来比喻双端队列，如下图(b)所示。在实际使用中，还可以有输出受限的双端队列（
java实现链表（模拟LinkedList）
zouzong123的博客
07-13 2253
      众所周知，链表是由一个个节点连接在一起，这里我们就先创建一个节点类，为了达到模拟效果，我们选择建一个Node的静态内部类。我们要想模拟LinkedList，就得先了解LinkedList的内包含的方法： add(Object）   dd(int,Object)   addFirst   addLast   get(int index)   remove    getIndex  rem...
LinkedList集合实现原理（即链表实现原理）
qq_41956016的博客
08-12 401
LinkedList是由链表实现的（它同时继承了List和Deque双端队列接口） 链表是：一个整体中有三个部分， 1、第一个部分存放的是“前一个的地址” 2、第二个部分存放的是“自己的具体内容” 3、第三个部分存放的是“后一个的地址” 代码实现原理： 节点类（Node<E>）： E item; //代表第二部分，存放自己的内容 Node<E> next; //代表...
LinkedList 是基于链表实现的
最新发布
07-28
是的，LinkedList 是一种基于链表实现的数据结构。链表是一种动态数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在 LinkedList 中，每个节点都会保存一个指向下一个节点的引用，从而将...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

肖大仙~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值