1、教练我想学算法（Java）——链表篇

🍁前言

1、看到一本挺不错的算法书，Hello 算法，图文并茂
放个链接 Hello-algo
（封面图也是引用书本的某一页）
2、以及LeetCode的练习题集合
Krahets 笔面试精选 88 题
正好算法题好久没刷了，在这里记录一下每周学习算法的过程
并放一些可以直接运行的Java代码和Leetcode题号
可供参考

🍁链表题目的解题关键

1、知道.next在左边是代表具体的下一个节点的位置，代表指针域
2、而如果.next在右边代表只是一个值
3、需要有建立虚拟节点的意识，遍历原有节点，而虚节点的next可以作为返回的头节点
4、判断循环结束条件要当心，注意空指针的情况

🍁一、合并两个有序链表

21.合并两个有序链表

1、本题思路主要在于依次比较即可
2、当一个遍历到尾后，另外一个链表直接拼到后面即可

public class L21 {
    public static class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    }
    //21. 合并两个有序链表
    public static ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        //如果有一个为空，则返回另一个
        if(list1 == null){
            return list2;
        }
        if(list2 == null){
            return list1;
        }
        //创建一个新链表
        //记录返回值
        ListNode res = new ListNode(-1);
        ListNode result = res;

        //循环比较两个链表，将小的值放入新链表中
        while(list1 != null && list2 != null){
            if(list1.val <= list2.val){
                res.next = list1;
                list1 = list1.next;
            }
            else {
                res.next = list2;
                list2 = list2.next;
            }
            //后移
            res = res.next;
        }

        //如果有一个链表为空，则将另一个链表直接连接到新链表的后面
        res.next = list1 == null ? list2 : list1;
        return result.next;
    }

    public static void main(String[] args) {
        //l1 = [1,2,4], l2 = [1,3,4]
        //构造L1
        ListNode l1 = new ListNode(1);
        l1.next = new ListNode(2);
        l1.next.next = new ListNode(4);
        //构造L2
        ListNode l2 = new ListNode(1);
        l2.next = new ListNode(3);
        l2.next.next = new ListNode(4);
        //合并两个链表
        ListNode result = mergeTwoLists(l1,l2);
        //循环输出
        while(result != null){
            System.out.println(result.val);
            result = result.next;
        }
    }
}

🍁二、反转链表

206.反转链表

1、本题思路主要是记录当前节点的前一个节点作为虚节点
2、以及后续节点的向后变化

public class L206 {
    public static class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    }
    //反转链表
    public static ListNode reverseList(ListNode head) {
        //确定虚节点和当前节点
        ListNode dummyNode = null;
        ListNode nowNode = head;

        //循环遍历整个链表
        while(nowNode != null){
            //记录当前节点的下一个节点
            ListNode nextNode = nowNode.next;
            nowNode.next = dummyNode;
            dummyNode = nowNode;
            nowNode = nextNode;
        }

        //返回的值就是最后节点的位置
        return dummyNode;
    }

    public static void main(String[] args) {
        //head = [1,2,3,4,5]
        ListNode head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);
        head.next.next.next = new ListNode(4);
        head.next.next.next.next = new ListNode(5);
        ListNode listNode = reverseList(head);
        while(listNode != null){
            System.out.println(listNode.val);
            listNode = listNode.next;
        }
    }
}

🍁三、分隔链表

86.分隔链表

1、 本题的话需要理解题意，不用保持强制有序
2、记录左右区间的大小判断即可

public class L86 {
    public static class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    }

    public static ListNode partition(ListNode head, int x) {

        // 记录左区间和右区间的起始位置
        ListNode small = new ListNode(0);
        ListNode smallHead = small;
        ListNode large = new ListNode(0);
        ListNode largeHead = large;
        // 遍历链表
        //移动左右头
        while(head != null){
            if(head.val < x ){
                small.next = head;
                small = small.next;
            }else{
                large.next = head;
                large = large.next;
            }
            head = head.next;
        }
        // 连接左右区间
        // 让右节点制空，有结尾
        large.next = null;
        small.next = largeHead.next;
        return smallHead.next;
    }
    public static void main(String[] args) {
        int x = 3;
        ListNode head = new ListNode(1);
        head.next = new ListNode(4);
        head.next.next = new ListNode(3);
        head.next.next.next = new ListNode(2);
        head.next.next.next.next = new ListNode(5);
        head.next.next.next.next.next = new ListNode(2);
        ListNode node = partition(head,x);
        while (node != null){
            System.out.println(node.val);
            node = node.next;
        }
    }
}

🍁 四、删除链表中的节点

237.删除链表中的节点

1、这题的话比较简单，知道传入的是删除的节点即可
2、先把后面一个值的数值赋值过来，然后改变指针指向即可

   public static class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    }
    public static void deleteNode(ListNode node) {
        node.val = node.next.val;
        node.next = node.next.next;
    }

    public static void main(String[] args) {
        //head = [4,5,1,9], node = 5
        ListNode listNode = new ListNode(4);
        listNode.next = new ListNode(5);
        listNode.next.next = new ListNode(1);
        listNode.next.next.next = new ListNode(9);
        deleteNode(listNode.next);
        while (listNode != null) {
            System.out.println(listNode.val);
            listNode = listNode.next;
        }
    }

🍁五、 随机链表的复制

138.随机链表的复制

1、本题比较有意思，难点在于每次创建的新节点，需要复用
2、用Map结构实现复用，如果不存在才创建
3、用递归/回溯的方法，返回当前已经创建好的节点

public class L138 {
    static class Node {
        int val;
        Node next;
        Node random;

        public Node(int val) {
            this.val = val;
            this.next = null;
            this.random = null;
        }
    }

    //map 存储的键值对为当前节点是否以及创建了新的节点
    static Map<Node, Node> cachedNode = new HashMap<Node, Node>();
    public static Node copyRandomList(Node head) {
        if(head == null){
            return null;
        }
        //如果还没有创建
        if(!cachedNode.containsKey(head)){
            Node node = new Node(head.val);
            //记录当前节点的新节点创建情况
            cachedNode.put(head, node);
            //创建next的指向
            node.next = copyRandomList(head.next);
            //创建random的指向
            node.random = copyRandomList(head.random);
        }
        //回溯出口
        return cachedNode.get(head);
    }

    public static void main(String[] args) {
        //输入：head = [[1,1],[2,1]]
        //输出：[[1,1],[2,1]]
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        node1.next = node2;
        node1.random = node2;
        node2.next = null;
        node2.random = node2;
        Node copyNode = copyRandomList(node1);
        while(copyNode != null){
            System.out.println(copyNode.val);
            if(copyNode.random != null){
                System.out.println(copyNode.random.val);
            }
            if (copyNode.next != null){
                System.out.println(copyNode.next.val);
            }
            copyNode = copyNode.next;
        }
    }
}