数据结构与算法之单链表(增{包含增序增加}、删、改、查、链表反转、有序链表合并{包含递归和非递归两种方式})

直接上代码吧，后面再总结一下：

public class SinglyLinkedList {

    // 头节点
    private final Node headNode = new Node(0, "", "");

    /**
     * 添加节点
     *
     * @param newNode 新节点
     */
    public void add(Node newNode) {
        Node temp = headNode;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.next = newNode;
    }

    /**
     * 遍历整个链表
     */
    public void foreachLinkedList() {
        if (headNode.next != null) {
            System.out.println(headNode.next);
        } else {
            System.out.println("linkedList is empty...");
        }
    }

    /**
     * 删除节点
     *
     * @param no 节点编号
     */
    public void remove(int no) {
        boolean removeFlag = false;
        Node temp = headNode;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == no) {
                removeFlag = true;
                break;
            }
            temp = temp.next;
        }
        if (removeFlag) {
            temp.next = temp.next.next;
        } else {
            System.out.printf("%d does not exists...\n", no);
        }
    }

    /**
     * 按照节点编号自然序插入节点
     *
     * @param newNode 新节点
     */
    public void orderByAdd(Node newNode) {
        Node temp = headNode;
        boolean isExists = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == newNode.no) {
                isExists = true;
                break;
            }
            if (temp.next.no > newNode.no) {
                break;
            }
            temp = temp.next;
        }
        if (isExists) {
            System.out.printf("%d number node is exists, does not add\n", newNode.no);
        } else {
            newNode.next = temp.next;
            temp.next = newNode;
        }
    }

    /**
     * 修改链表节点
     *
     * @param node 需要修改的节点
     */
    public void update(Node node) {
        Node temp = headNode;
        boolean isExists = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == node.no) {
                isExists = true;
                break;
            }
            temp = temp.next;
        }
        if (isExists) {
            temp.next.name = node.name;
            temp.next.nickname = node.nickname;
        } else {
            System.out.printf("%d number node does not exists\n", node.no);
        }
    }

    /**
     * 获取节点信息
     *
     * @param no 节点编号
     */
    public void get(int no) {
        Node temp = headNode;
        boolean isExists = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == no) {
                isExists = true;
                break;
            }
            temp = temp.next;
        }
        if (isExists) {
            System.out.println(temp.next);
        } else {
            System.out.printf("%d number does not exists\n", no);
        }
    }

    static class Node {
        private final int no;
        private String name;
        private String nickname;
        private Node next;

        public Node(int no, String name, String nickname) {
            this.no = no;
            this.name = name;
            this.nickname = nickname;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "no=" + no +
                    ", name='" + name + '\'' +
                    ", nickname='" + nickname + '\'' +
                    ", next=" + next +
                    '}';
        }
    }
}

// 测试类
public class SinglyLinkedListTest {
    public static void main(String[] args) {
        SinglyLinkedList.Node node1 = new SinglyLinkedList.Node(1, "宋江", "及时雨");
        SinglyLinkedList.Node node2 = new SinglyLinkedList.Node(2, "卢俊义", "玉麒麟");
        SinglyLinkedList.Node node3 = new SinglyLinkedList.Node(3, "吴用", "智多星");
        SinglyLinkedList.Node node4 = new SinglyLinkedList.Node(4, "林冲", "豹子头");
        SinglyLinkedList.Node node5 = new SinglyLinkedList.Node(5, "武松", "行者");
        // 按照插入顺序添加节点
        SinglyLinkedList sll = new SinglyLinkedList();
        sll.add(node1);
        sll.add(node5);
        sll.add(node2);
        sll.add(node4);
        sll.add(node3);
        // 遍历节点
        System.out.println(">>> 顺序添加节点以后, 遍历链表: ");
        sll.foreachLinkedList();
        // 根据节点编号删除节点
        sll.remove(1);
        sll.remove(3);
        sll.remove(5);
        sll.remove(4);
        sll.remove(2);
        // 遍历删除后的链表
        System.out.println(">>> 删除完链表以后, 遍历链表: ");
        sll.foreachLinkedList(); // 会提示链表为空的警告
        System.out.println(">>> 删除链表中不存在的编号: ");
        sll.remove(2); // 此时链表为空, 如果再删会提示2编号不存在的警告
        // 使用排序方法添加节点
        sll.orderByAdd(node1);
        sll.orderByAdd(node5);
        sll.orderByAdd(node2);
        sll.orderByAdd(node4);
        sll.orderByAdd(node3);
        System.out.println(">>> 使用排序方法插入节点以后, 遍历链表: ");
        sll.foreachLinkedList();
        System.out.println(">>> 使用排序方法插入链表已存在的编号: ");
        sll.orderByAdd(node3); // 提示3号编号节点已存在的警告
        // 修改节点, 将吴用改为浪子燕青(编号不变)
        SinglyLinkedList.Node node3$ = new SinglyLinkedList.Node(3, "燕青", "浪子");
        sll.update(node3$);
        System.out.println(">>> 更新节点之后, 遍历链表: ");
        sll.foreachLinkedList();
        // 查询节点
        System.out.println(">>> 查询链表中的3号节点: ");
        sll.get(3);
    }
}

// 测试结果
>>> 顺序添加节点以后, 遍历链表: 
    Node{no=1, name='宋江', nickname='及时雨', next=Node{no=5, name='武松', nickname='行者', next=Node{no=2, name='卢俊义', nickname='玉麒麟', next=Node{no=4, name='林冲', nickname='豹子头', next=Node{no=3, name='吴用', nickname='智多星', next=null}}}}}
>>> 删除完链表以后, 遍历链表: 
    linkedList is empty...
>>> 删除链表中不存在的编号: 
    2 does not exists...
>>> 使用排序方法插入节点以后, 遍历链表: 
    Node{no=1, name='宋江', nickname='及时雨', next=Node{no=2, name='卢俊义', nickname='玉麒麟', next=Node{no=3, name='吴用', nickname='智多星', next=Node{no=4, name='林冲', nickname='豹子头', next=Node{no=5, name='武松', nickname='行者', next=null}}}}}
>>> 使用排序方法插入链表已存在的编号: 
    3 number node is exists, does not add
>>> 更新节点之后, 遍历链表: 
    Node{no=1, name='宋江', nickname='及时雨', next=Node{no=2, name='卢俊义', nickname='玉麒麟', next=Node{no=3, name='燕青', nickname='浪子', next=Node{no=4, name='林冲', nickname='豹子头', next=Node{no=5, name='武松', nickname='行者', next=null}}}}}
>>> 查询链表中的3号节点: 
    Node{no=3, name='燕青', nickname='浪子', next=Node{no=4, name='林冲', nickname='豹子头', next=Node{no=5, name='武松', nickname='行者', next=null}}}

 

总结一下：
    1. add方法的思路就是找到最后一个节点的位置, 然后把最后一个节点的next引用指向新增的节点
    2. orderByAdd的思路(可以实现在内存中给数据排序的功能):
        1) 链表没有节点或者新节点是链表最大的节点
        2) 找到第一个编号比新节点大的节点：将大节点赋给新节点的next引用, 将新节点赋给大节点前一个节点的next引用
        3) 新链表中已有新节点
    3. remove的思路:
        1) 没找到这个节点
        2) 找到了这个节点：找到需要删除的这个节点的前一个节点, 然后将前一个节点的next.next节点赋给该节点的next节点
    4. update思路:
        1) 没找到这个节点
        2) 找到了这个节点: 将节点的新data信息替换掉旧节点的data信息
    5. get思路:
        1) 没找到这个节点
        2) 找到了这个节点: 打印节点信息
注意事项:
    以上操作在找节点的过程都是用的while循环, 切记加上while循环退出的遍历条件(temp = temp.next), 以免造成死循环

 ------------------------------------------------2020/7/19 单链表知识点复习---------------------------

1. 链表反转

    public Node reverse() {
        Node newHead = new Node(0, "", "");
        Node curNode = headNode.next;
        while (curNode != null) {
            Node next = curNode.next; // 摘节点时需要先把下一个节点保存起来
            curNode.next = newHead.next;
            newHead.next = curNode;
            curNode = next;
        }
        return newHead.next;
    }

2. 两个有序(升序)链表合并之后依然有序，非递归

    public static Node merge(Node n1, Node n2) {
        if (n1 == null) return n2;
        if (n2 == null) return n1;
        Node newHead = new Node(0, "", "");
        Node temp = newHead;
        while (n1 != null && n2 != null) {
            if (n1.no < n2.no) {
                temp.next = n1;
                n1 = n1.next;
            } else {
                temp.next = n2;
                n2 = n2.next;
            }
            temp = temp.next;
        }
        if (n1 != null) {
            temp.next = n1;
        } else {
            temp.next = n2;
        }
        return newHead.next;
    }

3. 两个有序(升序)链表合并之后依然有序，递归

    public static Node merge2(Node n1, Node n2) {
        if (n1 == null) return n2;
        if (n2 == null) return n1;
        if (n1.no < n2.no) {
            n1.next = merge2(n1.next, n2);
            return n1;
        } else {
            n2.next = merge2(n1, n2.next);
            return n2;
        }
    }