线性表链表实现

package cn.yuli.list;

public class MyLinkedList<T> {
    private Node<T> head;//链表头结点
    private Node<T> tail;//链表尾节点
    private int size = 0;
    public MyLinkedList(){
        clean();
    }
    /**
     * 清空链表
     */
    public void clean(){
        head = new Node<T>(null, null, null);
        tail = new Node<T>(head,null,null);
        head.next = tail;
        size = 0 ; 
    }
    /**
     * 判断链表是否为空
     * @return
     */
    public boolean isEmpty(){
        return this.size == 0;
    }
    /**
     * 尾部追加一个数据
     * @param data
     */
    public void add(T data){
        add(size,data);
    }
    /**
     * 在链表中添加一个数据
     * @param index
     * @param data
     */
    public void add(int index,T data){
        addBefore(getNode(index), data);
    }
    /**
     * 修改一个node的数据
     * @param index
     * @param data
     * @return
     */
    public T set(int index,T data){
        Node<T> node = getNode(index);
        T oldData = node.data;
        node.data = data;
        return oldData;
    }
    /**
     * 获得索引下的数据
     * @param index
     * @return
     */
    public T get(int index){
        return getNode(index).data;
    }
    /**
     * 通过折半查找法查询到索引节点
     * @param index
     * @return
     */
    public Node<T> getNode(int index){
        Node<T> node = null;
        if(index<0||index>size){
            throw new IndexOutOfBoundsException();
        }
        if(index < size /2){
            node = head.next;
            for(int i = 0;i<index;i++){
                node = node.next;
            }
        }else{
            node = tail;
            for(int i = size;i> index ; i--){
                node = node.prev;
            }
        }
        return node;
    }
    /**
     * 在节点之前添加数据
     * @param node
     * @param data
     */
    public void addBefore(Node<T> node,T data){
        Node<T> newNode = new Node<>(node.prev, data, node);
        newNode.prev.next = newNode;
        newNode.next.prev = newNode;
        this.size++;
    }
    /**
     * 删除某个节点
     * @param node
     * @return
     */
    public T remove(Node<T> node){
        node.prev.next = node.next;
        node.next.prev = node.prev;
        this.size--;
        return node.data;
    }
    /**
     * 移除索引节点
     * @param index
     * @return
     */
    public T remove(int index){
        return remove(getNode(index));
    }
    /**
     * 长度
     * @return
     */
    public int size(){
        return this.size;
    }
    /**
     * 节点元素
     * @author yuli
     *
     * @param <T>
     */
    private static class Node<T>{
        T data;//保存的对象
        Node<T> prev;//前一个元素
        Node<T> next;//下一个元素
        public Node(Node<T> prev,T data,Node<T> next) {
            this.data = data;
            this.prev = prev;
            this.next = next;
        }
    }
}