16 单向链表

所谓链表就好像火车车厢那样，从火车头开始，每一节车厢之后都连着后一节车厢

想要实现链表，则肯定要设计一个链表的节点类，在此类中必须有一个属性可以保存下一个节点的引用地址：

class Node{        // 定义节点类
    private String data ;    // 保存节点内容
    private Node next ;        // 表示保存下一个节点
    public Node(String data){        // 通过构造设置节点内容
        this.data = data ;    // 设置内容
    }
    public void setNext(Node next){
        this.next = next ;        // 设置下一个节点
    }
    public Node getNext(){    // 取得下一个节点
        return this.next ;
    }
    public String getData(){
        return this.data ;    // 取得节点的内容
    }
};
public class LinkDemo01{
    public static void main(String args[]){
        Node root = new Node("火车头") ;  // 定义根节点
        Node n1 = new Node("车厢-A") ;    // 定义第一个车厢（第一个节点）
        Node n2 = new Node("车厢-B") ;    // 定义第二个车厢（第二个节点）
        Node n3 = new Node("车厢-C") ;    // 定义第三个车厢（第三个节点）
        root.setNext(n1) ;            // 设置火车头的下一个节点是第一个车厢A
        n1.setNext(n2) ;            // 设置第一个车厢的下一个节点是第二个车厢
        n2.setNext(n3) ;            // 设置第二个车厢的下一个节点是第三个车厢
        printNode(root) ;            // 从头开始输出
    }
    public static void printNode(Node node){    // 输出节点
        System.out.print(node.getData() + "\t") ;    // 输出节点的内容
        if(node.getNext()!=null){        // 判断此节点是否存在下一个节点
            printNode(node.getNext()) ;    // 向下继续输出
        }
    }
};

（注：本程序中，所有的关系都是通过用户手工进行设置的，如果要想让其真正变得有意义，则需要为其加入一个操作的封装。）

 

假设现在的节点操作有以下几种：增加数据，查找数据，删除数据。特别强调的是，如果要删除节点的话，则直接修改上一个节点的引用即可

class Link{        // 链表的完成类
    class Node{    // 保存每一个节点，此处为了方便直接定义成内部类
        private String data ;    // 保存节点的内容
        private Node next ;        // 保存下一个节点
        public Node(String data){
            this.data = data ;        // 通过构造方法设置节点内容
        }
        public void add(Node newNode){        // 将节点加入到合适的位置
            if(this.next==null){            // 如果下一个节点为空，则把新节点设置在next的位置上
                this.next = newNode ;
            }else{        // 如果不为空，则需要向下继续找next
                this.next.add(newNode) ;
            }
        }
        public void print(){
            System.out.print(this.data + "\t") ;    // 输出节点内容
            if(this.next!=null){        // 还有下一个元素，需要继续输出
                this.next.print() ;    // 下一个节点继续调用print
            }
        }
        public boolean search(String data){    // 内部搜索的方法
            if(data.equals(this.data)){        // 判断输入的数据是否和当前节点的数据一致
                return true ;
            }else{    // 向下继续判断
                if(this.next!=null){    // 下一个节点如果存在，则继续查找
                    return this.next.search(data) ;    // 返回下一个的查询结果
                }else{
                    return false ;        // 如果所有的节点都查询完之后，没有内容相等，则返回false
                }
            }
        }
        public void delete(Node previous,String data){
            if(data.equals(this.data)){    // 找到了匹配的节点
                previous.next = this.next ;    // 空出当前的节点
            }else{
                if(this.next!=null){    // 还是存在下一个节点
                    this.next.delete(this,data) ;    // 继续查找
                }
            }
        }
    };
    private Node root ;        // 链表中必然存在一个根节点
    public void addNode(String data){    // 增加节点
        Node newNode = new Node(data) ;    // 定义新的节点
        if(this.root==null){            // 没有根节点
            this.root = newNode ;    // 将第一个节点设置成根节点
        }else{        // 不是根节点，放到最后一个节点之后
            this.root.add(newNode) ;    // 通过Node自动安排此节点放的位置
        }
    }
    public void printNode(){        // 输出全部的链表内容
        if(this.root!=null){        // 如果根元素不为空
            this.root.print() ;    // 调用Node类中的输出操作
        }
    }
    public boolean contains(String name){    // 判断元素是否存在
        return this.root.search(name) ;    // 调用Node类中的查找方法
    }
    public void deleteNode(String data){        // 删除节点
        if(this.contains(data)){    // 判断节点是否存在
            // 一定要判断此元素现在是不是根元素相等的
            if(this.root.data.equals(data)){    // 内容是根节点
                this.root = this.root.next ;    // 修改根节点，将第一个节点设置成根节点
            }else{
                this.root.next.delete(root,data) ;    // 把下一个节点的前节点和数据一起传入进去
            }
        }
    }
};
public class LinkDemo02{
    public static void main(String args[]){
        Link l = new Link() ;
        l.addNode("A") ;        // 增加节点
        l.addNode("B") ;        // 增加节点
        l.addNode("C") ;        // 增加节点
        l.addNode("D") ;        // 增加节点
        l.addNode("E") ;        // 增加节点
        System.out.println("======= 删除之前 ========") ;
        l.printNode() ;
        // System.out.println(l.contains("X")) ;
        l.deleteNode("C") ;        // 删除节点
        l.deleteNode("D") ;        // 删除节点
        l.deleteNode("A") ;        // 删除节点
        System.out.println("\n====== 删除之后 =========") ;
        l.printNode() ;
        System.out.println("\n查询节点：" + l.contains("B")) ;
    }
};