简单的单向链表实例代码-java版

《java开发实战》里的代码

单向链表最简单的实现：

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 LinkDemo1
{
    public static void main(String args[]){
        //实例以下节点
        Node root=new Node("A");
        Node node1=new Node("B");
        Node node2=new Node("C");
        Node node3=new Node("D");
        //建立节点之间的关系 root->node1->node2->node3
        root.setNext(node1);
        node1.setNext(node2);
        node2.setNext(node3);
        
        //输出所有节点
        printNode(root);


    }
    //定义输出所有节点的方法
    public static void printNode(Node node){
        //输出节点信息
        System.out.print(node.getData()+"-->");

        //如果还有节点
        if(node.getNext()!=null){
            printNode(node.getNext());//再调用方法本身
        }else{
            System.out.print("null");
        }
    }
}

运行结果：

 

经过封装后的单向链表的实现：

class Link //链表类
{
    class Node//节点类
    {
        private String data;
        private Node next;
        //构造方法
        public Node(String data){
            this.data=data;
        }
        
        //添加节点
        public void add(Node next){
            //当前节点如果为空
            if(this.next==null){
                this.next=next;//将参数节点赋给当前节点
            }else{
                this.next.add(next);//如果当前节点不为空，则递归调用添加方法直到有空节点为止
            }
        }

        //输出所有节点
        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)){//比较字符串用equals,=号是比较对象
                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 contains(String name){
        return this.root.search(name);//查询调用节点类的查找方法
    }

    //进一步封装删除节点的方法
    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 LinkDemo2
{
    public static void main(String[]args){
        Link link=new Link();
        link.addNode("A");
        link.addNode("B");
        link.addNode("C");
        link.addNode("D");


        System.out.println("\n==========删除之前===========");
        link.printNode();//输出所有节点。

        link.deleteNode("C");//删除C节点

        System.out.println("\n==========删除之后===========");
        link.printNode();//再次输出所有节点

        System.out.println("\n");
    
        //查找指定的节点
        System.out.println("要查找的节点C是否存在："+link.contains("C"));
    }
}

运行结果：