LinkedList 链表 Java 实现

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 isEmpty();

    boolean contains(E element);

    void add(E element);

    void add(int index, E element);

    E get(int index);

    E set(int index, E element);

    E remove(int index);

    int indexOf(E element);
}

2、抽象类的实现

2.1、关于抽象类的相关知识

2.2、抽象类的代码实现

package com.luobin.力扣数据结构练习题目.接口的定义;

/**
 * @author LuoBin
 * @version 1.0
 * @date 2021/9/3 4:18 下午
 * <p>
 * 业务实现逻辑：
 * ArrayList 和 LinkedList 都继承了抽象类 AbstractList ，
 * 而 AbstractList 实现了 List 接口，由于本身为抽象类，不需要实现接口中的全部类，实现部分即可，其余的交给子类进行实现，
 * 这样设计，可以减少代码的重复，实现了代码的多次使用；
 */

// 定义抽象线性表
// 将动态数组和链表之间的具有相同功能的代码进行抽象
// 抽象类本身是不能创建对象的，符合设计思想
// 只负责抽取公共的代码，不对外公开

/**
 * 业务实现逻辑：
 * ArrayList 和 LinkedList 都继承了抽象类 AbstractList ，
 * 而 AbstractList 实现了 List 接口，由于本身为抽象类，不需要实现接口中的全部类，实现部分即可，其余的交给子类进行实现，
 * 这样设计，可以减少代码的重复，实现了代码的多次使用；
 */

/**
 * 此处的抽象类，可以对于接口中的部分功能进行实现，也可以只进行方法的声明
 */
public abstract class AbstractList<E> implements List<E> {
    private int size;

    // protected 是只有子类可以使用，同一个类，同一个包的类可以调用
    protected void rangeCheckForAdd(int index) {
        if (index < 0 || index >= 10) {
            outOfBound(index);
        }
    }

    public void rangeCheck(int index) {
        if (index < 0 || index >= 10) {
            outOfBound(index);
        }
    }

    private void outOfBound(int index) {
        throw new IndexOutOfBoundsException("Index:" + index + ",Size" + size);
    }

    //判断是否为空
    public boolean isEmpty() {
        return size == 0;
    }
}

3、链表的相关操作代码实现（详细情况请查看注释）

/**
 * 关于时间复杂度的问题，链表的数据操作中，只有在元素的插入或者删除的那一刻，时间复杂度是 O(1),整体封装好的函数来讲
 * 时间复杂度是：o(n)
 */
// 在类名后面指定尖括号意味着您正在创建一个可以保存任何类型数据的临时数据类型
public class MyLinkedList<E> extends AbstractList<E> {

    // 链表的大小
    private int size;

    // 链表的头结点，头结点是一个结构体，first 表示创建的指针
    private Node first;

    @Override
    public void clear() {
        size = 0;
        first = null;
    }


    /**
     * 遍历链表查看是否包含传递进来的参数
     *
     * @param element
     * @return
     */
    @Override
    public boolean contains(E element) {
        for (int i = 0; i < size; i++) {
            first = first.next;
            if ((element).equals(first)) {
                System.out.println("true");
                return true;
            } else {
                break;
            }
        }
        return false;
    }

    // 单独将元素添加进去
    // 采用调用按照索引添加的方式
    // 默认将元素添加到最后面
    public void add(E e) {
        // 此处调用了加入的方法，根据位置，进行元素的加入
        add(size, e);
    }

    /**
     * 插入的原理：
     * 1、找到需要加入的前面的一个元素，让前面的元素指向插入的元素，插入的元素指向后面的位置
     * 2、先进行插入操作，然后进行连接操作，为了使得连接顺畅，需要创建中间变量
     * 3、由于在插入的时候，后面有连接起来的操作，需要将pre.next 先保存到临时变量当中，结点使用自己的属性值以及指向下一个元素
     * <p>
     * 指针，也就是下一个元素的引用
     */
    @Override
    public void add(int index, E element) { // O(n)
        // 传入的参数为 0 的情况下的特殊处理
        if (index == 0) {
            // 原始的链表中没有元素，构造器构造新的元素,创建出来头结点
            first = new Node<>(element, first);

        } else {
            // Node<E> prev = node(index - 1);
            // 创建新的结点，元素是传进来的参数，下一个指针指向
            // 破坏了以前的结点所指向的下一个元素的连接，目前前一个结点的指针指向新的结点

            Node<E> prev = node(index - 1);

            // 前一个节点指向新加入的节点，新加入的节点指向原来的后面的节点
            prev.next = new Node<>(element, prev.next);
        }
        // 元素的数量的添加
        size++;
    }

    // 获取指定节点的 element 元素值
    @Override
    public E get(int index) { // O(1)
        return node(index).element;
    }

    // 将对应索引的元素值覆盖掉，返回原来的节点的 element
    // index 只能保证插入的结点的位置
    @Override
    public E set(int index, E element) {// O(1)
        Node<E> node = node(index);
        E old = node.element;
        node.element = element;
        return old;
    }

    /**
     * 删除节点的思想：
     * 首先找到删除元素的前置节点，使得：前置节点.next = 前置节点.next.next；
     * 就是将不要的元素隔离掉
     *
     * @param index
     * @return
     */
    @Override
    public E remove(int index) {
        rangeCheck(index);
        Node<E> node;

        if (index == 0) {
            node = first;
            first = first.next;
        } else {
            // 获取索引前面的元素
            Node<E> prev = node(index - 1);
            // 定义的 node 是为了接收 找到的前一个元素的下一个元素的element
            node = prev.next;
            prev.next = prev.next.next;
        }

        size--;
        // 将删除的元素的值返回
        return node.element;
    }

    // 将需要寻找的对象传递进去，找到的话，I
    @Override
    public int indexOf(E element) {
        // 允许了空值的传递，此处调用 下面的 equals() 会报错，需                                                      要处理
        if (element == null) {
            Node<E> node = first;
            for (int i = 0; i < size; i++) {
                if (node.element == null) return i;
                node = node.next;
            }
        } else {
            Node<E> node = first;
            for (int i = 0; i < size; i++) {
                // 判断当前的对象与传入进去的对象是否一致
                // == 只是会比较引用地址
                // 把 element 放到前面，因为已经判断了，过来一定是非空的，使用 equals() 比较即可
                if ((element.equals(node.element))) {
                    return i;
                }
                node = node.next;
            }
        }
        return ELEMENT_NOT_FOUND;
    }

    // 写一个方法，通过索引返回需要找到的节点,在它的前面加节点
    // 获取 index 对应节点的对象
    // private 只能是同一个类才能使用,其他都不可以
    private Node<E> node(int index) { // O(n)
        rangeCheckForAdd(index);

        // first 最开始在链表的最前面，index 控制寻找到节点的次数
        // node充当一个指针，用来寻找节点
        Node<E> node = first;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node;
    }

    @Override
    public String toString() {
        // java 中进行字符串的拼接 使用 StringBuilder,提升效率
        StringBuilder res = new StringBuilder();
        res.append("size = " + size + "\n");
        res.append("[");
        Node<E> node = first;
        for (int i = 0; i < size; i++) {
            res.append(node.element);

            // size 是数组的大小，实际比索引是大一个的，所以此处需要减去 1
            if (i != size - 1) {
                res.append(",");
            }

            node = node.next;
        }
        res.append("]");
        return res.toString();
    }

    public void sizeGet() {
        System.out.println("size : " + size + "\n");
    }

    // 链表节点的设置问题
    private static class Node<E> {
        // 每个节点拥有自己的存储元素，同时也有自己的指向下一个元素的指针
        E element;
        Node<E> next;

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