java实现单链表

public class LinkedList {
    /**
     * 头节点
     */
    private Node headNode = new Node();
    /**
     * 用内部类表示节点,如果内部类是访问权限是private，那么不能通过 new LinkedList().new Node()来创建对象。
     * 就算在外部类中定义一个返回内部类对象的方法，也会在 LinkedList.Node node = linkedList.newNode();时报错
     */
    public class Node{
        private int id;
        private String content;
        private Node next;
        public Node(){}

        public Node(int id, String content) {
            this.id = id;
            this.content = content;
        }

        public int getId() {
            return id;
        }

        public void setNum(int id) {
            this.id = id;
        }

        public String getContent() {
            return content;
        }

        public void setContent(String content) {
            this.content = content;
        }

        public Node getNext() {
            return next;
        }

        public void setNext(Node next) {
            this.next = next;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "id=" + id +
                    ", content='" + content + "\'}";
        }
    }

    public Node getHeadNode() {
        return headNode;
    }

    public void setHeadNode(Node headNode) {
        this.headNode = headNode;
    }
    //    public Node newNode(){
//        return new Node();
//    }
//    public Node newNode(int id, String content, Node next){
//        return new Node(id, content,next);
//    }
    /**
     *  链表添加,默认添加到最后
     */
    public void addLinkedList(Node node){
        Node temp = headNode;
        while(true){
            if(temp.next == null){
                temp.next = node;
                break;
            }
            temp = temp.next;
        }
    }
    /**
     *  链表添加，按id顺序
     */
    public void addLinkedListById(Node node){
        Node temp = headNode;
        boolean flag = false;
//        Node connection;
        while(true){
            if(temp.next == null){
                flag = true;
                break;
            }
//            这样会空指针if(temp.next.id > node.id || temp.next == null)
            if(temp.next.id > node.id){
//                  node.next = temp.next;
//                  temp.next = node;
//                connection = temp.next;
//                temp.next = node;
//                node.next = connection;
                flag = true;
                break;
            }else if(temp.next.id == node.id){
                System.out.println("id重复");
                break;
            }
            temp = temp.next;
        }
        if(flag){
            node.next = temp.next;
            temp.next = node;
        }
    }

    /**
     * 链表删除，先找出位置再删除
     * @param id
     */
    public void deleteLinkedList(int id){
        Node temp = headNode;
        while(true){
            if(temp.next == null){
                System.out.println("没找到结点,删除失败");
                break;
            }
            if(temp.next.id == id){
                temp.next = temp.next.next;
                break;
            }
            temp = temp.next;
        }

    }
    /**
     * 改链表
     */
    public void updateLinkedList(int id,String content){
        Node temp = headNode;
        while(true){
            if(temp.next == null){
                System.out.println("未找到需要更新的节点");
                break;
            }
            if(temp.next.id == id ){
                temp.next.content = content;
                break;
            }
            temp = temp.next;
        }
    }
    /**
     *  查链表
     */
    public void readLinkedList(){
        Node temp = headNode;
        while(true){
            if(headNode.next == null){
                System.out.println("链表为空！");
                break;
            }
            if(temp.next == null){
                System.out.println("遍历结束");
                break;
            }
            System.out.println(temp.next);
            temp = temp.next;
        }

    }
    /**
     *  获取单链表中有效节点的个数
     */
    public int getLength(){
        Node temp = headNode;
        int count = 0;
        while(true){
            if(temp.next == null){
                break;
            }
            count++;
            temp = temp.next;
        }
        return count;
    }
    /**
     *  查找单链表中倒数第k个有效节点，这里使用快慢指针
     */
    public Node findLastIndexNode(int index){
        /**
         *  先判断 index合法性
         */
        int length = getLength();
        if(index <= 0 || index > length){
//            System.out.println("输入数字有误请检查");
            throw new RuntimeException("输入数字有误请检查!");
        }
        Node temp = headNode;
        for (int i = 0,j = i + (index - 1); j < length ; i++,j++) {
            temp = temp.next;
        }
        return temp;
    }
    /**
     *  单链表的反转
     */
    public void reverseLinkedList(){
        if(headNode.next == null || headNode.next.next == null){
            System.out.println("链表为空或长度为1，无需反转。");
            return;
        }
        Node reverseHead = new Node();
        Node temp = headNode.next;
//        Node temp = headNode;
        Node next = null;
        while(true){
            if(temp == null){
                break;
            }
            next = temp.next;
            temp.next = reverseHead.next;
            reverseHead.next = temp;
            temp = next;
//            reverseHead.next = temp.next;
//            temp.next = temp.next.next;
//            temp = temp.next;
        }
        headNode.next = reverseHead.next;
    }
    /**
     *  单链表按反转顺序打印，不改变链表结构
     */
    public void reversePrint(){
        if(headNode.next == null){
            System.out.println("链表为空，无需打印");
            return;
        }
        Node temp = headNode.next;
        Stack<Node> nodes = new Stack<>();
        while(temp != null){
            nodes.push(temp);
            temp = temp.next;
        }
        while(nodes.size() > 0){
            System.out.println(nodes.pop());
        }
    }
    /**
     *  合并两个有序链表，和并后依旧有序。有序的依据是id
     */
    public LinkedList unionLinkedList(LinkedList l1){
        if(l1.getLength() == 0){
            return this;
        }
        if(this.getLength() == 0){
            return l1;
        }
        /**
         *  循环条件判断采用或为空，在方法体内分类讨论
         */
        LinkedList unionLinkedList = new LinkedList();
        Node temp1 = this.headNode.next;
        Node temp2 = l1.getHeadNode().next;
        Node next;
        while(temp1 != null || temp2 != null){
            if(temp1.id <= temp2.id ){
                next = temp1.next;
                temp1.next = null;
                unionLinkedList.addLinkedList(temp1);
                temp1 = next;
            }else{
                /**
                 * 添加节点前需要将next置空否则会一起添加过去
                 */
                next = temp2.next;
                temp2.next = null;
                unionLinkedList.addLinkedList(temp2);
//                System.out.println(temp2.next);
                temp2 = next ;
            }
            if(temp1 == null) {
//                while (temp2 != null) {
//                    unionLinkedList.addLinkedList(temp2);
//                    temp2 = temp2.next;
//                }
                unionLinkedList.addLinkedList(temp2);
                return unionLinkedList;
            } else if (temp2 == null) {
//                while (temp1 != null){
//                    unionLinkedList.addLinkedList(temp1);
//                    temp1 = temp1.next;
//                }
                unionLinkedList.addLinkedList(temp1);
                return unionLinkedList;
            }
        }
        return unionLinkedList;
    }
}