链表

　　链表 组成元素：由多个链接点组成，每个链接点是一个类的对象，里面装有需要的数据。并且还有对象自身的引用，用于定位下一个节点，或者加一个自身的引用定位上一个节点。

　　下面展示一个单链表也即只能往前或者往后遍历链表的使用。

package com.test;

public class LinkListApp {

    public static void main(String[] args) {
        
        LinkList linkList = new LinkList();
        linkList.insertFirst(1, 1.0);
        linkList.insertFirst(2, 2.0);
        linkList.insertFirst(3, 3.0);
        linkList.insertFirst(4, 4.0);
        
        linkList.displayList();
        
        System.out.println("删除末端节点："+linkList.deleteFirst()); 
        System.out.println("根据关键字查找："+linkList.find(2));
        System.out.println("根据关键字删除："+linkList.delete(2));
        
        
    }
}


/**
 * 链表对象
 * @author jingxin
 *
 */
class Link{
    /**
     * 链表对象里的数据（iData,dData）
     * 链表对象的下一个引用 next
     */
    public int iData;
    public double dData;
    public Link next;
    
    public Link(int id,double dd){  // 构造函数
        this.iData = id;
        this.dData = dd;
    }
    
    public void displayLink(){  // 显示当前链表元素
        System.out.print("{"+iData+","+dData+"}");
    }

    @Override
    public String toString() {
        return "Link [iData=" + iData + ", dData=" + dData + "]";
    }
    
}

/**
 * 单向链表
 * @author jingxin
 *
 */
class LinkList{
    /**
     * 链表中第一个链接点的引用,从first出发可以通过Link对象的next指向下一个链接点
     * first:也即当前节点
     */
    private Link first;
    
    public LinkList(){  // 构造函数
        first = null;
    }
    
    public boolean isEmpty(){
        return first == null;
    }
    
    /**
     * 添加节点
     * 因为初始first为空，新插入的节点，给first，然后该节点的next指向空
     * @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(){
        if(isEmpty()){
            return null;
        }
        Link oldLink = first;
        first = first.next;
        return oldLink;
    }
    
    /**
     * 查找节点
     * @param key
     * @return
     */
    public Link find(int key){
        if(!isEmpty()){
            Link current = first;
            while(current.iData!=key){
                if(current.next == null){
                    return null;
                }
                else{
                    current = current.next;
                }
            }
            // 找到节点了
            return current;
        }
        return null;
    }
    
    /**
     * 根据关键字删除节点
     * @param key
     */
    public Link delete(int key){
        if(!isEmpty()){
            // 当前节点
            Link current = first;
            // 前一个节点
            Link previous = first;
            while(current.iData!=key){
                if(current.next==null){
                    return null;
                }else{
                    previous = current;
                    current = current.next;
                }
            }
            // 找到了
            if(current == first){  // 删除的是第一个节点
                first = first.next;
            }else{
                 previous.next = current.next;
            }
            return current;
        }
        return null;
    }
    
    /**
     * 显示整个链表
     */
    public void displayList(){
        Link current = first;
        while(current!=null){
            current.displayLink();
            current = current.next;
        }
        System.out.println("");
    }
    
}