单向链表实例

 本篇也是一道应用Java面向对象基础篇知识的程序实例，通过理解掌握小模型实例，为日后进行实际开发奠定基础 

链表 就是链式地存储数据，是一种常见的数据结构。链表就好比火车，一节跟着一节 

 有以下一道程序：

class Node {  //定义节点
    private String data;
    private Node next;   //保存下一个节点
    public Node(String data){
        this.data = data;
    }
    public String getData(){
        return this.data;
    }
    public void setNext(Node next){
        this.next = next;
    }
    public Node getNext(){
        return this.next;
    }
}
public class NodeDemo01 {
    public static void main(String[] args) {
        Node root = new Node("火车头");   //定义根节点
        Node node1 = new Node("车厢-A");  //定义第一个车厢
        Node node2 = new Node("车厢-B");  //定义第二个车厢
        Node node3 = new Node("车厢-C");  //定义第三个车厢
        root.setNext(node1);    //火车头的下一个节点是第1个车厢
        node1.setNext(node2);   //第1个车厢的下一个节点是第2个车厢
        node2.setNext(node3);   //第2个车厢的下一个节点是第3个车厢
        printNode(root);        //从根节点开始输出，进行递归调用
    }
    public static void printNode(Node node){
        System.out.println(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){
                    this.next = newNode;
                }else{
                    this.next.add(newNode);
                }
            }
            public void print(){           //定义链表节点输出打印方法
                System.out.print(this.data + "\t");
                if(this.next!=null){     //如果下一个节点不为空，则继续输出打印
                    this.next.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;
                    }
                }
            }
            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);
        }
    }
    public void printNode(){  //封装打印输出节点操作
        if(this.root!=null){
            this.root.print();
        }
    }
    public Boolean searchNode(String name){  //封装搜索节点操作
        return this.root.search(name);
    }
    public void deleteNode(String data){  //封装删除节点操作
        if(this.searchNode(data)){
            if(this.root.data.equals(data)){
                this.root = this.root.next;
            }else{
                this.root.next.delete(root,data);
            }
        }
    }
}
public class LinkDemo {
    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();  //换行
        System.out.println("查询B节点是否存在：" + l.searchNode("B"));  //搜索节点
        l.deleteNode("D");  //删除节点
        System.out.println("--------删除之后--------");
        l.printNode();
    }
}

程序运行结果：

以上程序对要操作的节点类 进行了包装，主方法直接调用包装后的类，即可执行节点的增加 、删除 、查找操作