台哥算法练习 自己写的一个LinkedList

package suanfa;

/**
 * 当年学习数据结构和算法的时候，自己写的一个LinkedList，
 * 可以看到，LinkedList是动态链表，插入和删除的效率比较高，查询其长度的效率比较低
 * 
 * 推荐一本学习数据结构和算法的书籍，《数据结构java版》清华大学出版社，译者梁志敏
 * 
 * @author 台哥  https://blog.csdn.net/chaohi
 * 
 * @param <T>
 */
public class LinkedList<T> {
    private Node<T> node;
    private int listSize;

    // 构造方法
    public LinkedList() {
        node = new Node<T>();
        listSize = 0;
    }

    // 在索引index处添加元素
    public void add(int index, T element) {
        if (index < 0 || index > listSize) {
            return;
        }
        Node<T> preNode = node;
        for (int i = 0; i < index; i++)
            preNode = preNode.next;
        Node<T> newNode = new Node<T>(element);
        if (preNode.next != null) {
            preNode.next.prev = newNode;
            newNode.next = preNode.next;
        }
        newNode.prev = preNode;
        preNode.next = newNode;
        listSize++;
    }

    // 在尾部添加元素并返回true
    public boolean add(T element) {
        this.add(listSize, element);
        return true;
    }

    // 返回第一个element元素的索引
    public int indexOf(T element) {
        Node<T> curNode = node;
        for (int i = 0; i <= listSize - 1; i++) {
            curNode = curNode.next;
            if (curNode.equals(element))
                return i;
        }
        return -1;
    }

    // 返回最后一个element元素的索引
    public int lastIndexOf(T element) {
        int index = -1;
        Node<T> curNode = node;
        for (int i = 0; i <= listSize - 1; i++) {
            curNode = curNode.next;
            if (curNode.equals(element))
                index = i;
        }
        return index;
    }

    // 得到索引index处的节点
    public Node<T> getNode(int index) {
        Node<T> curNode = node;
        for (int i = 0; i <= index; i++) {
            curNode = curNode.next;
        }
        return curNode;
    }

    // 得到索引index处的元素
    public T get(int index) {
        if (index < 0 || index >= listSize) {
            return null;
        }
        return this.getNode(index).value;
    }

    // 为索引index处的元素赋值
    public T set(int index, T element) {
        if (index < 0 || index >= listSize) {
            return null;
        }
        T previousValue = this.get(index);
        Node<T> curNode = this.getNode(index);
        curNode.value = element;
        return previousValue;
    }

    // 删除索引index处的元素
    public T remove(int index) {
        if (index < 0 || index >= listSize) {
            return null;
        }
        Node<T> curNode = this.getNode(index);
        curNode.prev.next = curNode.next;
        if (curNode.next != null)
            curNode.next.prev = curNode.prev;
        listSize--;
        return curNode.value;
    }

    // 删除列表中的element元素
    public boolean remove(T element) {
        int index = this.indexOf(element);
        if (index != -1) {
            this.remove(index);
            return true;
        }
        return false;
    }

    // 返回列表的长度
    public int size() {
        return listSize;
    }

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

    // 清空列表
    public void clear() {
        node = null;
        listSize = 0;
    }

    // 判断列表中是否存在元素element
    public boolean contains(T element) {
        return !(this.indexOf(element) == -1);
    }

    // 节点
    @SuppressWarnings("hiding")
    private class Node<T> {
        public T value;
        public Node<T> prev;
        public Node<T> next;

        public Node() {
        };

        public Node(T t) {
            this.value = t;
        }
    }

    // 测试
    public static void main(String[] args) {
        LinkedList<String> l = new LinkedList<String>();
        l.add("台哥");
        l.add("taigecailing");
        l.add(1, "当当当当");
        System.out.println("size=:" + l.size());

        for (int i = 0; i < l.size(); i++) {
            System.out.print(l.get(i) + " , ");
        }
        System.out.println();
        
        l.remove(2);
        System.out.println(l.get(2));
    }

}