自己写一个简单的LinkedList

之前写了一遍关于ArrayList的简略版，现在来一遍关于LinkedList的简略版（ps 通过查看源码个人认为jdk源码中的LinkedList有很多啰嗦重复的方法）。

• 首先LinkedList实现一个链表。由这个类定义的链表也可以像栈或队列一样被使用。这是百度百科的说法。所以我们首先需要新建一个链表类。由于这个链表类只是在LinkedList里面使用，故采取静态内部类的方式

    /**
     * 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的
     * 链表允许插入和移除表上任意位置上的节点，但是不允许随机存取。
     *
     * @param <E>
     */
    private static class Entry<E>{
        E element;
        Entry<E> next;
        Entry<E> previous;
        Entry(E element, Entry<E> next, Entry<E> previous) {
            this.element = element;
            this.next = next;
            this.previous = previous;
        }
    }

为了和JDK源码的LinkedList区分，我的类名叫SimpleLinkedList。

• 定义一个header作为集合的开始
  private Entry<E> header = new Entry<E>(null,null,null);

• 构造器 初始化集合

    public SimpleLinkedList(){
        header.next = header;
        header.previous = header;
    }

• 在链表尾部添加元素

    public boolean add(E e){
        addBefore(e, header);
        return true;
    }

公共方法addBefore(E,Entry)的实现

    private Entry<E> addBefore(E e,Entry<E> entry){
        Entry<E> newEntry = new Entry<E>(e,entry,entry.previous);
        newEntry.previous.next=newEntry;
        newEntry.next.previous=newEntry;
        size++;
        return newEntry;
    }

• 在链表头部添加元素

public void addFirst(E e){
        addBefore(e, header.next);
    }

其实JDK里面还有个方法addLast(E) 和add()方法一样，这里就不列出了

• 获取元素
  获取第一个和最后一个元素，由于链表结构，header作为零界点，下一个指向第一个元素；上一个指向最后一个

    public E getFirst(){
        return header.next.element;
    }

    public E getLast(){
        return header.previous.element;
    }

• 根据指定的位置获取元素（随机获取元素相对ArrayList来说，这个效率很低）

public E get(int index){
        return entry(index).element;
    }

公共代码entry(int)

private Entry<E> entry(int index) {
        Entry<E> e = header;
        if(index < (size >>1)){
            for(int i=0;i<=index;i++){
                e = e.next;
            }
        }else{
            for(int i=size; i>index; i--){
                e = e.previous;
            }
        }
        return e;
    }

如果要获取的index小于链表size的一半（右移一位），则从开头0的位置找到index位置，如果大于size则从结尾找到index

• 替换指定位置元素set方法

public E set(int index,E e){
        Entry<E> entry = entry(index);
        E oldE = entry.element;
        entry.element = e;
        return oldE;
    }

• 移除元素

public E remove(int index){
        return remove(entry(index));
    }
    public E removeFirst(){
        return remove(header.next);
    }
    public E removeLast(){
        return remove(header.previous);
    }

    private E remove(Entry<E> e){
        if(e==header){
            throw new NoSuchElementException();
        }
        E result = e.element;
        e.next.previous = e.previous;
        e.previous.next = e.next;
        e.next = e.previous = null;
        e.element = null;
        size--;
        return result;
    }

另外JDK1.5后加入了一些和Queue相关的方法如pop，peek,push等。我简单的实现了几个，大致和上面的几个方法差不错。下面是完整的源码

/**
 * 模拟LinkedList的实现
 * 
 *
 */
public class SimpleLinkedList<E> {
    private int size = 0;
    private Entry<E> header = new Entry<E>(null,null,null);

    public SimpleLinkedList(){
        header.next = header;
        header.previous = header;
    }
    /**
     * 在链表结尾处新增一个元素
     * 实现原理，每次都在header前添加一个节点
     * @param e
     * @return
     */
    public boolean add(E e){
        addBefore(e, header);
        return true;
    }
    /**
     * 在链表开头添加元素
     * @param e
     */
    public void addFirst(E e){
        addBefore(e, header.next);
    }
    /**
     * 双链表结构，header的下一个，刚好是链表的第一个
     *         header的上一个，反而是最后一个元素
     * @return
     */
    public E getFirst(){
        return header.next.element;
    }

    public E getLast(){
        return header.previous.element;
    }

    public int size(){
        return size;
    }

    /**
     * 返回指定坐标的元素
     */
    public E get(int index){
        return entry(index).element;
    }

    private Entry<E> entry(int index) {
        Entry<E> e = header;
        /**
         * 右移一位相当于除以2
         * 如果坐标小于长度的一半，从0开始找，一直找到当前坐标，返回当前e的下一个
         * 如果要查找的坐标大于链表长度的一半，从末尾找到该坐标的前一个，返回当前e的上一个
         */
        if(index < (size >>1)){
            for(int i=0;i<=index;i++){
                e = e.next;
            }
        }else{
            for(int i=size; i>index; i--){
                e = e.previous;
            }
        }
        return e;
    }
    /**
     * 替换指定坐标的元素
     * @param index
     * @param e
     * @return
     */
    public E set(int index,E e){
        Entry<E> entry = entry(index);
        E oldE = entry.element;
        entry.element = e;
        return oldE;
    }

    public E remove(int index){
        return remove(entry(index));
    }
    public E removeFirst(){
        return remove(header.next);
    }
    public E removeLast(){
        return remove(header.previous);
    }

    private E remove(Entry<E> e){
        if(e==header){
            throw new NoSuchElementException();
        }
        E result = e.element;
        e.next.previous = e.previous;
        e.previous.next = e.next;
        e.next = e.previous = null;
        e.element = null;
        size--;
        return result;
    }




    //----------queue的一些方法
    /**
     * add 和 offer 的区别在于
     * 当队列为空add报错，offer返回false
     * LinkedList里面还有区别，add是list方法，offer是Queue方法
     * @param e
     * @return
     */
    public boolean offer(E e){
        return add(e);
    }

    /**
     * 将元素推入此列表所表示的堆栈。
     * 其实就是在list开头添加元素
     * 堆的出入规则，先进后出
     * @param e
     */
    public void push(E e){
        addFirst(e);
    }
    /**
     * 从此列表所表示的堆栈处弹出一个元素。
     * 其实是头部弹出一个元素
     * @return
     */
    public E pop(){
        return removeFirst();
    }
    /**
     * 获得第一个元素，与pop相对，它不删除元素
     * @return
     */
    public E peek(){
        if(size ==0){
            return null;
        }
        return getFirst();
    }

    /**
     * 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的
     * 链表允许插入和移除表上任意位置上的节点，但是不允许随机存取。
     *
     * @param <E>
     */
    private static class Entry<E>{
        E element;
        Entry<E> next;
        Entry<E> previous;
        Entry(E element, Entry<E> next, Entry<E> previous) {
            this.element = element;
            this.next = next;
            this.previous = previous;
        }
    }
    private Entry<E> addBefore(E e,Entry<E> entry){
        Entry<E> newEntry = new Entry<E>(e,entry,entry.previous);
        newEntry.previous.next=newEntry;
        newEntry.next.previous=newEntry;
        size++;
        return newEntry;
    }

}