第三天：线性表之链式储存

package cn.mdj.singlelink;

class Link{
    //链表是由节点组成，所以定义一个Node节点
    private class Node{
        //节点的数据分为 数据域 和指针域 所以： 每一个指针域指向下一个节点，而数据域是可以存放任何数据类型
        private Object data;
        private Node next;
        //数据传入，即节点实例化后，就要将数据封装起来
        public Node(Object data){
            this.data = data;
        }
        
        public void addNode(Node newNode){
            if(this.next == null){
                this.next = newNode;
            }else{
                this.next.addNode(newNode);
            }
        }
        
        public boolean containsNode(Object data){
            if(this.data.equals(data)){
                return true;
            }else{
                if(this.next == null){
                    return false;
                }else{
                    return  this.next.containsNode(data);
                }
            }
        }
        
        public void removeNode(Node pre,Object data){
            if(data.equals(this.data)){
                pre.next = this.next;
            }else{
                if(this.next != null){
                    this.next.removeNode(this, data);
                }
            }
        }
        
        public Object getNode(int index){
            if(Link.this.foot == index){
                return this.data;
            }else{
                Link.this.foot++;
                return this.next.getNode(index);
            }
        }
        
        public void toArrayNode(){
            Link.this.restData[Link.this.foot++] = this.data;
            if(this.next != null){
                this.next.toArrayNode();
            }
        }
    }
    
    //节点定义好后，那么首先需要的是一个根节点
    private Node root;
    private int  count = 0;
    private int foot =0;
    private Object[] restData = null;
    //添加节点
    public boolean add(Object data){
        //将数据包装成节点
        Node newNode = new Node(data);
        if(this.root == null){
            this.root = newNode;
        }else{
            this.root.addNode(newNode);
        }
        this.count++;
        return true;
    }
    
    //既然可以添加节点，当然是可以删除节点的，但要删除，那么首先肯定要查找是否包含这个节点，所以：
    public boolean contains(Object data){
        if(this.root == null || data == null){
            return false;
        }
        return this.root.containsNode(data);
    }
    
    //有了节点的查找，下面来删除节点
    public void remove(Object data){
        //首先查找，是否存在
        if(this.contains(data)){
            //首先判断是否是根节点
            if(this.root.data.equals(data)){
                this.root = this.root.next;
                
            }else{
                this.root.next.removeNode(this.root,data);
            }
        }
        this.count--;
    }
    
    //有了增加 删除 查找，当然应该有获取指定的对象，和判断是否为空链表
    
    //获取
    public Object get(int index){
        
        //而要获取指定位置的索引，索引要合法，即不能超过链表的总数，所以在上面定义一个count
        if(this.count > index){
            //需要一个角标，从而来去和index，判断所以定义一个foot
            this.foot = 0;
            return this.root.getNode(index);
        }else{
            return null;
        }
    }
    
    public boolean emptyLink(){
        return this.count == 0;
    }
    
    public int size(){
        return this.count;
    }
    
    //对象数组输出
    public Object[] toArray(){
        if(this.root == null){
            return null;
        }
        this.foot = 0;
        this.restData = new Object[this.count];
        this.root.toArrayNode();
        return this.restData;
    }
    
}

public class SingleLink {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Link all = new Link() ;
        all.add("Hello") ;
        all.add("World") ;
        all.remove("World") ;
        Object array [] = all.toArray() ;    // 取得全部数据
        for (int x = 0 ; x < array.length ; x ++ ) {
            System.out.println(array[x]) ;
        }
        System.out.println(all.contains("Hello")) ;
        System.out.println(all.get(0)) ;
        System.out.println(all.get(1)) ;
    }
}