Java数据结构之手写LinkedList

LinkedList的实现本质为一个双向链表，下面是简单的实现增删改查：

public class LinkedList<E> {

    Node<E> first;
    Node<E> last;

    public int size;
    public LinkedList(){

    }

    public void add(E e){
        linkLast(e);
    }
    public void change(int index,E e){

        if (size<0||size<index){
            return;
        }
        Node<E> target=node(index);
        target.item=e;
    }

    /**
     * 删除指定的节点
     * @param index
     */
    public void remove(int index){
        if (size<0|size<index){
            return;
        }
        //找到节点
        Node<E> target=node(index);
        unLinkList(target);
    }

    public void unLinkList(Node<E> target){
        //目标节点的前后节点
        Node<E> pre=target.prev;
        Node<E> next=target.next;
        //把前后节点连接起来
        if (pre==null){
            first=target.next;
        }else{
            pre.next=target.next;
        }

        if (next==null){
            last=target.prev;
        }else{
            next.prev=target.prev;
        }
        size--;
    }
    /**
     *添加节点到指定的位置
     * @param index 位置索引
     * @param e
     */
    public void add(int index,E e){
        //超过总长
        if (size<0||index>size){
            return;
        }else{
            //在尾部
            if (size==index){
                linkLast(e);
            }else{
                //找到目标节点
                Node<E> target=node(index);
                //断开目标节点
                Node<E> pre=target.prev;
                Node<E> node= new Node<E>(pre,e,target);
                //前后连接
                if (pre==null){
                    first=node;
                }else{
                    pre.next=node;
                }
                target.prev=node;
                size++;
            }
        }
    }


    /**
     * 根据索引获取值
     * @param index i
     * @return
     */
    public E get(int index){

        if (size<0||size<index){
            return null;
        }
        return node(index).item;
    }

    private Node<E> node(int index){

        if (index<(size>>1)){
            Node<E> node=first;
            for (int i = 0; i <index ; i++) {
                node=node.next;
            }
            return node;
        }else{
            Node<E> node=last;
            for (int i = size-1; i >index ; i--) {
                node=node.prev;
            }
            return node;
        }
    }

    /**
     * 向链表添加一个节点 到尾部
     * @param e
     */
    private void linkLast(E e){
        Node<E> newNode=new Node<E>(last,e ,null);

        Node<E> l=last;
        last = newNode;
        //没有节点
        if (l==null){
           first=newNode;
        }else{
            l.next=newNode;
        }
        size++;
    }

    private static class Node<E>{
        E item;
        Node<E> next;
        Node<E> prev;
        Node(Node<E> prev,E element,Node<E> next){
            this.item=element;
            this.prev=prev;
            this.next=next;
        }
    }
}