数据结构与算法[单链表结构用java代码实现]

public class SingleLinkedList {
//2.针对单链表 ：节点个数 便与遍历；还有一个是头节点；
    private int size;//节点个数
    private Node head;//头节点
    /**
     * 元素：节点
     */
    private class Node{
        private Object data; //内部类的元素，存放类型是object
        private Node next; //指向下一个节点地址

        public Node() {
        }

        public Node(Object data) {
            this.data = data;
        }
    }

    /**
     * 添加节点 从头部插入节点
     * @param obj
     * @return
     */
    public Object addNode(Object obj){
        Node newHead = new Node(obj); //每次新加的节点都是头节点
//        if(size == 0){
//            head = newHead; //没有数据则头指针数据指向新增加的节点元素
//        }else{
//            newHead.next=head;//当前节点的下一个节点的地址是原先head的地址
//            head = newHead;//将head指向当前节点
//        }
        newHead.next=head;
        head = newHead;
        size++;
        return obj;
    }

    /**
     * 判断单链表是否为空
     * @return
     */
    public boolean isEmpty(){
        return size==0;
    }

    /**
     * 删除头节点
     * @return
     */
    public Object deleteHead(){
        Node node = head;
        head = head.next;
        size--;
        return node;

    }

    /**
     * 查找元素节点
     * @param obj
     * @return
     */
    public Node find(Object obj){
        Node current = head;
        int tempSize = size;
       while(tempSize>0){
           if(current.data.equals(obj)){//equals比较的是object的内容
                return current;
           }else{
               current = current.next;
           }
           tempSize--;
       }
        return null;
    }

    /**
     * 删除节点
     * @param obj
     * @return
     */
    public Node deleteNode(Object obj){
        if(size==0) return null;
        Node current  = head;//指定当前元素节点为头节点
        Node previous = head;//指定前驱节点为头节点
        while(current.data != obj){ //如果当前节点的数和待删除的数不一致则继续
            if(current.next != null){
                previous = current;
                current = current.next;
            }else{
                return null;
            }
        }
        //判断如果当前节点是第一个head节点
        if(current.equals(head)){
            head = current.next;
            size--;
        }else{ //删除不是头节点的
            //当前节点不再有任何节点指向它，当前节点的前驱节点直接指向了当前节点的下一个节点
            previous.next=current.next;
            size--;
        }
        return current;
    }

    /**
     * 遍历单链表
     * @param args
     */
    public void display(){
        if(size>0){
            Node node = head;
            int tempSize = size;
            //如果当前节点只有一个
            if(tempSize == 1){
                System.out.println("["+node.data+"]");
                return;
            }
            while(tempSize>0){
                if(node.equals(head)){//起始节点
                    System.out.print("["+node.data+"-->");
                }else if(node.next == null){//尾节点
                    System.out.print(node.data+"]");
                }else{//中间节点
                    System.out.print(node.data+"-->");
                }
                node = node.next;//当前节点指向下一个节点 继续循环
                tempSize--;
            }
            System.out.println();
        }else{
            //链表没有元素节点,则直接打印[]
            System.out.println("[]");
        }
    }

    public static void main(String[] args) {
        System.out.println("hhh");
        SingleLinkedList singList = new SingleLinkedList();
        singList.addNode("zhangsan");
        singList.addNode("lisi");
        singList.addNode("wangwu");
        singList.display();
        singList.deleteHead();
        singList.display();
       Node node = singList.find("zhangsan");
        System.out.println(node.data);
        singList.display();
       Node den = singList.deleteNode("lisi");
        System.out.println(den.data);
        Node den1 = singList.deleteNode("zhangsan");
        singList.display();
    }
}