链表（三）

链表的效率：

在表头插入和删除数据项很快，仅需要改变一两个引用值，所花费时间O(1)。
平均起来，删除、查找、在指定的链接点插入 仅需要搜索一半的数据，需要O(N)次比较。在数据执行这些操作也需要O(N)次比较，但链表更快一些，因为插入删除数据项时，链表不需要移动其它数据项。
链表比数组优越的重要方面在于链表需要多少内存就用多少内存，并且可以扩展到其它所有可用的内存。数组的大小从创建时就定义好，所以经常由于数组太大导致效率低下，或者数组太小空间溢出。向量是一种可扩展的数组，但它只允许以固定的大小增长扩展（溢出时增长一倍数组容量），在内存使用率比链表的低。

 

ADT：抽象数据类型，是指一些数据以及对这些数据所进行的的操作的集合。

 

双向链表：提供 向前 / 向后 遍历整个链表，因为每个链接点都有两个指向其它链接点的引用。
缺点：每次 插入 / 删除 链接点，都要处理四个链接点的引用（两个连接前一个链接点，两个连接后一个链接点）。由于多了两个引用，占用的空间也更大了。

与双端链表的区别：可以提供removeLast()

public class Link {

    private int iData;
    private double dData;
    
    private Link next;

    // 针对双向链表
    private Link previous;

    public Link(int i, double d) {
    　　this.iData = i;
    　　this.dData = d;
    }

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

    public Link getNext() {
    　　return next;
    }

    public void setNext(Link next) {
    　　this.next = next;
    }

    public int getiData() {
    　　return iData;
    }

    public double getdData() {
    　　return dData;
    }

    public Link getPrevious() {
    　　return previous;
    }

    public void setPrevious(Link previous) {
    　　this.previous = previous;
    }

}

public class DoublyLinkList {

    private Link first;
    private Link last;

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

    public void insertFirst(int i, double d) {
    　　Link newLink = new Link(i, d);
    　　if (isEmpty())
        　　last = newLink;
    　　else
        　　first.setPrevious(newLink);
    　　newLink.setNext(first);
    　　first = newLink;
    }

    public void insertLast(int i, double d) {
    　　Link newLink = new Link(i, d);
    　　if (isEmpty()) {
        　　first = newLink;
    　　} else {
        　　last.setNext(newLink);
        　　newLink.setPrevious(last);
   　　 }
    　　last = newLink;
    　　}

    public Link deleteFirst() {
    　　Link l = first;
    　　if (first.getNext() == null)
        　　last = null;
    　　else
        　　first.getNext().setPrevious(null);
    　　first = l.getNext();
    　　return l;
    }

    public Link deleteLast() {
    　　Link l = last;
    　　if (first.getNext() == null)
        　　first = null;
    　　else
        　　last.getPrevious().setNext(null);
    　　last = last.getPrevious();
    　　return l;
    }

    public Link find(int key) {
    　　Link current = first;
    　　while (current != null) {
        　　if (current.getiData() == key) {
        　　　　return current;
        　　}
        　　current = current.getNext();
    　　}
    　　return null;
    }

    public Link delete(int key) {
    　　Link l = find(key);
    　　if (l != null) {
        　　if (l.getPrevious() != null) {
        　　　　l.getPrevious().setNext(l.getNext());
        　　} else {
        　　　　first = l.getNext();
        　　}
    　　}
    　　return l;
    }

    public void displayListForward() {
    　　Link current = first;
    　　System.out.println("FirstLastList (First --> Last)");
    　　while (current != null) {
        　　current.displayLink();
        　　current = current.getNext();
    　　}
    }

    public void displayListBackward() {
    　　Link current = last;
    　　System.out.println("FirstLastList (Last --> First)");
    　　while (current != null) {
        　　current.displayLink();
        　　current = current.getPrevious();
    　　}
    }

}

    public static void main(String[] args) {
    　　DoublyLinkList ll = new DoublyLinkList();
    
    　　ll.insertFirst(5, 1.6);
    　　ll.insertFirst(6, 1.7);
    　　ll.insertFirst(0, 0.7);
    　　ll.insertLast(2, 1.8);
    　　ll.insertLast(8, 8.8);
    　　ll.insertLast(100, 8.8);
    　　ll.displayListForward();
    　　ll.deleteLast();
    　　ll.deleteFirst();
    　　ll.displayListForward();
    　　System.out.println("delete 5 --> " );
    　　ll.delete(5).displayLink();
    　　ll.displayListForward();
    }

打印结果：
FirstLastList (First --> Last)
{ 0 , 0.7 }
{ 6 , 1.7 }
{ 5 , 1.6 }
{ 2 , 1.8 }
{ 8 , 8.8 }
{ 100 , 8.8 }
FirstLastList (First --> Last)
{ 6 , 1.7 }
{ 5 , 1.6 }
{ 2 , 1.8 }
{ 8 , 8.8 }
delete 5 -->
{ 5 , 1.6 }
FirstLastList (First --> Last)
{ 6 , 1.7 }
{ 2 , 1.8 }
{ 8 , 8.8 }