链表（一）

在链表中，每个数据项都被包含在<链接点>（Link）中，一个链接点是某个类的对象，这个类可以叫做Link。
每个Link对象都包含一个对下一个链接点引用的字段（next）。

public class Link {
    public int iData;
    public double dData;
    public Link next;
}

引用和基本类型：

在链表的环境中，很容易对<引用>产生混淆。
在Java语言中，Link对象并没有真正包含另一个Link对象，尽管看起来像是包含了，类型为Link的next字段仅仅对另一个Link对象的“引用”，而不是一个对象。
一个引用是对一个对象的参照数值，它是计算机内存中一个地址，所有的引用，不管它指向谁，大小都是一样的。对编译器来说，知道这个字段大小从而构造整个Link对象，是没有问题的。

对于int和double等基本数据类型，含有的字段并不是引用，而是实实在在的值。例如 double salary = 2000.0;
它在内存地址创建了一个空间，然后把数值2000.0放进去。
如：Link newLink = new Link();
newLink字段并没有真正拥有一个对象，它仍然是个引用。这个对象存在内存某个地方。
Link otherLink = newLink;
newLink把自己本身对Link的引用放到变量otherLink中。

单链表：

public class Link {
    
    private int iData;
    private double dData;
    private Link next;
    
    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 class LinkList
{
    private Link first;

    public void addFirst(int i, double d)
    {
        Link newLink = new Link(i, d);
        newLink.setNext(first);
        first = newLink;
    }

    public Link removeFirst()
    {
        Link f = first;
        first = first.getNext();
        return f;
    }

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

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

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

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

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

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

}

    public static void main(String[] args)
    {
        LinkList ll = new LinkList();
        ll.addFirst(2, 2.8);
        ll.addFirst(7, 7.6);
        ll.addFirst(5, 5.5);
        ll.addFirst(9, 9.5);
        ll.addFirst(12, 12.5);
        ll.addFirst(14, 14.5);
        ll.addFirst(16, 16.5);
        ll.removeFirst();
        System.out.println("------------DISPLAY");
        ll.display();
        System.out.println("------------FIND");
        ll.find(12).displayLink();
        System.out.println("------------DELETE");
        ll.delete(14).displayLink();
        System.out.println("------------DISPLAY");
        ll.display();
    }

打印结果：
------------DISPLAY
{ 14 , 14.5 }
{ 12 , 12.5 }
{ 9 , 9.5 }
{ 5 , 5.5 }
{ 7 , 7.6 }
{ 2 , 2.8 }
------------FIND
{ 12 , 12.5 }
------------DELETE
{ 14 , 14.5 }
------------DISPLAY
{ 12 , 12.5 }
{ 9 , 9.5 }
{ 5 , 5.5 }
{ 7 , 7.6 }
{ 2 , 2.8 }

有序链表：

    public void insert(int i, double d) {
    　　Link newLink = new Link(i, d);
    　　Link previous = null;
    　　Link current = first;
    　　while (current != null && i > current.getiData()) {
        　　previous = current;
        　　current = current.getNext();
    　　}
    　　if (previous == null) {
        　　first = newLink;
        　　newLink.setNext(current);
    　　} else {
        　　previous.setNext(newLink);
        　　newLink.setNext(current);
    　　}
    }