数据结构-链表

参考《Java数据结构和算法》
链表的机制灵活，用途广泛，插入和删除比较快，查找较慢。
链表分为单链表、双端链表、有序链表、双向链表和有迭代器的链表。

单链表

链式存取的结构，为找到第i个数据，必须先找到第i-1个数据元素。

public class Link {

    public int iData ;
    public double dData ;
    public Link next ;//下一个节点

    public Link(int id,double dd){
        iData = id ;
        dData = dd ;

    }

    public void displayLink(){
        System.out.println("{"+iData+","+dData+"}");
    }
}

public class LinkList {

    private Link first ;

    public LinkList(){
        first = null;
    }

    public boolean isEmpty(){
        return first == null;
    }

    /**
     * 在链表头插入一个数据项
     * @param id
     * @param dd
     */
    public void insertFirst(int id,double dd){
        Link newLink = new Link(id, dd);
        newLink.next = first;
        first = newLink;
    }

    /**
     * 在链表头删除一个数据项
     * @return
     */
    public Link deleteFirst(){
        Link temp = first;
        first = first.next;//将first指向下一个元素
        return temp ;
    }

    public void displayList(){
        Link current = first;
        while(current != null){
            current.displayLink();
            current = current.next;
        }

    }

    /**
     * 根据条件查找指定数据项
     * @param key
     * @return
     */
    public Link find(int key){
        Link current = first;
        while(current.iData != key){
            if(current.next == null){
                return null;
            }else{
                //将引用指向下一个元素
                current = current.next;
            }
        }

        return current;
    }

    public Link delete(int key){
        Link current = first;//当前指向的数据项
        Link previous = first;//前一个数据项
        while(current.iData != key){
            if(current.next == null){
                return null;
            }else{
                //如果不符合条件，将previous指向当前的数据项,current指向next数据项
                previous = current;
                current = current.next;
            }
        }

        if(current == first){
            //如果要删除的数据项是第一项,直接将first指向next
            first = first.next;
        }else{
            //如果要删除的数据项不是第一项，将previous.next指向要删除的数据项的
            previous.next = current.next;
        }
        return current;

    }
}

双端链表

双端链表有两个项，first和last，一个指向链表中的第一个链结点，另一个指向最后一个链结点。如果只有一个链结点，first和last都指向它，如果没有链结点，两者都为null。双端链表不能有助于删除最后一个链结点，因为没有一个引用指向倒数第二个链结点。

public class FirstLastList {

    private Link first ;
    private Link last ;

    public FirstLastList(){
        first = null;
        last = null;
    }

    public boolean isEmpty(){
        return first == null;
    }


    /**
     * 
     * @param id
     * @param dd
     */
    public void insertFirst(int id,double dd){
        Link newLink = new Link(id, dd);

        if(isEmpty())
            last = newLink;
        newLink.next = first;
        first = newLink;
    }

    public void insertLast(int id,double dd){
        Link newLink = new Link(id, dd);
        if(isEmpty())
            first = newLink;
        else 
            last.next = newLink;
        last = newLink;
    }

    public void displayList(){
        Link current = first ;
        while(current != null){
            current.displayLink();
            current = current.next;
        }
    }

    public Link deleteFirst(){
        Link temp = first;
        if(first.next == null){
            last = null;
        }

        first = first.next;
        return temp ;
    }

}

有序链表

有序链表中的数据是按照关键值有序排列的，有序链表的删除常常是只限于删除在链表头部的最小（或者最大）链结点。如果一个应用频繁的存取最小项，且不需要快速的插入，有序链表是一个有效的方案选择。有序链表优于有序数组的地方是插入的速度，链表可以扩展到全部有效的使用内存，而数组只能局限于一个固定的大小，当数组的内存不够用时，会进行扩容，把当前的数组拷贝到一个更大容量的新的数组。

Object[] newArray = new Object[s +
                    (s < (MIN_CAPACITY_INCREMENT / 2) ?
                     MIN_CAPACITY_INCREMENT : s >> 1)];
            System.arraycopy(a, 0, newArray, 0, s);
            array = a = newArray;

有序链表的实现参考一下代码：

public class SortedList {


    private Link first ;

    public SortedList(){
        first = null;
    }

    public boolean isEmpty(){
        return first == null;
    }

    /**
     * 
     * @param id
     * @param dd
     */
    public void insertFirst(int id,double dd){
        Link newLink = new Link(id, dd);
        Link previous = null;
        Link current = first;
        while(current != null && id>current.iData){
            previous = current;
            current = current.next;

        }

        if(previous == null){
            first = newLink;
        }else{
            previous.next = newLink;

        }

        newLink.next = current;
    }

    public void displayList(){
        Link current = first;
        while(current != null){
            current.displayLink();
            current = current.next;
        }

    }

    public Link remove(){
        Link temp = first;
        first = first.next;
        return temp;
    }
}

有序链表可以用于一种更高效的排序机制，做法是把数据从无序数组中取出，一个一个插入有序链表，最后再重新放入数组。缺点是需要开辟两倍的内存空间，因此适用于不太大的数组排序。

双向链表

双向链表允许向前遍历，也允许向后遍历整个链表。每个链结点有两个指向其他链结点的引用，即前一个和下一个。缺点是每次插入和删除一个链结点的时候，要处理四个链结点的引用。

public class Link {

    public long dData ;
    public Link next ;
    public Link previous ;

    public Link(long dd){
        this.dData = dd ;
    }

    public void displayLink(){
        System.out.println("{"+dData+"}");
    }
}