自己实现Linkedlist,实现其常用的增、删、查的方法

/**自己实现linkedlsit
 * 添加 addFirst(E e) addLast(E e)  add(E e)  add(int index,E e)
 * 获取 get(int index)  getLast() getFirst()
 * 删除 removeFirst()  remvoeLast()  remove()  remove(int index)  remove(Object o)
 * @author cuiyc
 * @version 1.0
 * @date 2021/6/5 10:22
 */
public class LinkedListDemo2<E> {
    /**
     * list的长度
     */
    private int size=0;
    /**
     * linkedlist的首节点
     */
    private Node first;
    /**
     * linkedlist的末尾节点
     */
    private Node last;

    /**
     * 定义一个静态内部类，即节点，包含前节点、元素、后节点
     * @param <E> 泛型参数
     */
    private static class Node<E>{
        E e;
        Node prev;
        Node next;

        public Node(Node prev,E e,Node next){
            this.e=e;this.prev=prev;this.next=next;
        }
    }

    /**
     * 空参构造函数
     */
    public LinkedListDemo2(){

    }

    /**
     * 在linkedlist的头部添加元素
     * @param e 要添加的元素
     */
    private void addFirst(E e){
        //向linkedlist的头部添加元素
        linkFirst(e);
    }

    /**
     * 在linkedlist的尾部添加元素
     * @param e 要添加的元素
     */
    private void addLast(E e){
        //向linkedlist的尾部添加元素
        linkLast(e);
    }

    /**
     * 添加元素，默认是向linkedlist的尾部添加元素
     * @param e 要添加的元素
     */
    private void add(E e){
        addLast(e);
    }

    /**
     * 向linkedlist的某个位置添加元素
     * @param index linkedlist的某个位置
     * @param e 要添加的元素
     */
    private void add(int index,E e){
        //1 判断index是否和目前linkedlist的长度相等，如果相等，则表示需要添加到链表的尾部，否则是添加到尾部之前的其他位置
        if(index==size){
            linkLast(e);
        }else {
            linkBefore(index,e);
        }
    }

    /**
     * 获取linkedlist的最后一个节点的元素
     * @return
     */
    private E getLast(){
        final Node<E> l=last;
        if(l==null){
            throw  new NoSuchElementException();
        }
        return l.e;
    }

    /**
     * 获取linkedlist的第一个节点元素
     * @return
     */
    private E getFirst(){
        final Node<E> f=first;
        if(f==null){
            throw new NoSuchElementException();
        }
        return f.e;
    }

    /**
     * 获取某个位置的节点元素
     * @param index 位置
     * @return
     */
    private E get(int index){
        final Node<E> n=node(index);
        if(n==null){
            throw new NoSuchElementException();
        }
        return n.e;
    }

    /**
     * 移除linkedlist中的第一个元素
     */
    private void removeFirst(){
        //1 找到first
        final Node<E> f=first;
        if(f==null){
            throw new NoSuchElementException();
        }
        unLinkFirst(f);
    }

    /**
     * 移除linkedlist的最后一个元素
     */
    private void removeLast(){
        //1 找到last node
        final Node<E> l=last;
        if(l==null){
            throw new NoSuchElementException();
        }
        unLinkLast(l);
    }

    /**
     * 移除linkedlist中的元素，模式是移除最后一个元素
     */
    private void remove(){
        removeLast();
    }

    /**
     * 移除linkedlist中的某个位置的元素
     * @param index 位置
     */
    private void remove(int index){
        final Node<E> n=node(index);
        unLink(n);
    }

    /**
     * 移除linkedlist中的某个元素的置
     * @param o 元素的值
     * @return
     */
    private Boolean remove(Object o){
        //如果元素的值为null 则循环判断链表，如果节点的值为null，则删除那个节点
        if(o==null){
            for (Node<E> n=first;n!=null;n=n.next){
                if(n.e==null){
                    unLink(n);
                    return true;
                }
            }
        }else {
            //如果元素的值不为null，则循环判断链表，如果节点的值等于当前元素的值，则删除当前节点。
            for (Node<E> n=first;n!=null;n=n.next){
                if(o.equals(n.e)){
                    unLink(n);
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 移除linkedlist中的某个节点
     * @param n
     */
    private E unLink(Node<E> n) {
        //拿到当前节点的元素值
        final E element=n.e;
        //拿到当前节点的上一个节点prev
        final Node<E>prev=n.prev;
        //拿到当前节点的下一个节点next
        final Node<E>next=n.next;
        //判断当前节点的上一节点是否为空，如果为空 则下一节点为first节点 如果不为空，则上一个节点的下一节点为next。并将当前节点的前一节点置空
        if(prev==null){
            first=next;
        }else {
            prev.next=next;
            n.prev=null;
        }
        //判断下一节点是否为空，如果为空，则上一节点为last节点 如果不为空 则当前节点的下一节点的上个节点是prev，并将当前节点的next置空
        if(next==null){
            last=prev;
        }else {
            next.prev=prev;
            n.next=null;
        }
        //当前节点的元素置空
        n.e=null;
        //元素的长度减1
        size--;
        return element;
    }


    /**
     * 移除linkedlist的最后一个元素的实现方法
     * @param l
     */
    private E unLinkLast(Node<E> l) {
        //1 找到最后一个节点的元素
        final E element=l.e;
        //2 找到最后一个节点前的那个节点
        final Node<E> prev=l.prev;
        //将最后一个节点的元素置空 最后一个节点的前一个节点指针置空 将倒数第二个节点数组为last节点
        l.e=null;
        l.prev=null;
        last=prev;
        //判断如果倒数第二个节点为空，则first也为空 如果不为空，则其next节点设置为空。
        if(prev==null){
            first=null;
        }else {
            prev.next=null;
        }
        size--;
        return element;
    }


    private E unLinkFirst(Node<E> f){
        //1 拿到第一个节点的元素
        final E element=f.e;
        //拿到第二个节点
        final Node<E> next=f.next;
        //将第一个节点的元素置空 第一个节点的next节点置空 再将next节点设置为first节点
        f.e=null;
        f.next=null;//有助于垃圾回收
        first=next;
        //判断next节点是否为空 如果为空，则last节点也为空，如果不为空，则将next的prev节点置为空。
        if(next==null){
            last=null;
        }else {
            next.prev=null;
        }
        size--;
        return element;
    }

    /**
     * 向linkedlist的头部添加元素的实现方法
     * @param e 要添加的元素
     */
    private void linkFirst(E e){
        //1 找到first节点
        final Node<E> f=first;
        //2 创建要添加的新的node节点
        final Node<E> newNode=new Node<>(null,e,f);
        //3 将要添加的新的node节点定义为first节点
        first=newNode;
        //4 判断之前的f即fist节点的有无，如果没有，表示添加的新的节点即是first节点也是last节点。如果之前有first节点，则将之前的
        //first的节点的prev执行新的first节点。
        if(f==null){
            last=newNode;
        }else {
            f.prev=newNode;
        }
        size++;
    }

    /**
     * 向linkedlist的尾部添加元素的实现方法
     * @param e 要添加的元素
     */
    private void linkLast(E e){
        //1 找到last节点
        final Node<E>l=last;
        //2 创建要添加的新的node节点，前一节点指向之前的last节点，后一节点指向null
        final Node<E>newNode=new Node<>(l,e,null);
        //3 将新创建的node节点定义为last节点
        last=newNode;
        //4 判断之前的定义的last节点l是否为空，如果为空，则表示之前没有节点存在，即新添加的元素即是first节点也是last节点
        // 如果之前定义的last节点l不为空，则将其next节点指向新创建的节点
        if(l==null){
            first=newNode;
        }else {
            l.next=newNode;
        }
        size++;
    }

    /**
     * 向linkedlist的除了尾部的其他位置添加元素
     * @param index  list的位置
     * @param e 要添加的元素
     */
    private void linkBefore(int index,E e){
        //1 通过index 在linkedlist中找到那个节点
        final Node<E> succ=node(index);
        //2 找到succ的前一个节点pred节点
        final Node<E> pred=succ.prev;
        //3 新建一个节点，元素是e 其下一节点是succ节点,上一个节点是pred节点
        final Node<E> newNode=new Node<>(pred,e,succ);
        //4 通过index找到的那个节点，设置其prev节点为newNode节点。
        succ.prev=newNode;
        //5 判断之前的succ的prev节点，是否为空。如果为空，表示newNode将是first节点，否则pred的next节点为newNode
        if(pred==null){
            first=newNode;
        }else {
            pred.next=newNode;
        }
        //6 linkedlist的长度加1
        size++;
    }

    /**
     * 通过index来查询linkedlist中的某个元素。
     * @param index
     * @return
     */
    private Node<E> node(int index) {
        //判断 index是分布在linkedlsit链表的左半部分还是右半部分  size>>1 即是size右移1位，size的0.5倍
        if(index<(size>>1)){
            Node<E> x=first;
            for (int i = 0; i < index; i++) {
                x=x.next;
            }
            return x;
        }else {
            Node<E> x=last;
            for (int i=size-1;i>size;i--){
                x=x.prev;
            }
            return x;
        }
    }
}