LeetCode-138. 复制带随机指针的链表-Java-medium

题目链接

Node

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

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

创建带头节点的随机指针链表

    /**
     * 创建带头节点的随机指针链表
     *
     * @param arr
     * @return
     */
    public Node creatRandomNextList(Integer[][] arr) {
        Node head = new Node(0); // 头节点
        if (arr.length == 0) {
            return head;
        }
        Node curNode = head;
        Map<Integer, Node> mp = new HashMap<>(); // 存储节点索引与节点之间的映射
        for (int i = 0; i < arr.length; i++) {   // 构建节点，填充next指针，构建映射
            Node newNode = new Node(arr[i][0]);
            curNode.next = newNode;
            curNode = curNode.next;
            mp.put(i, curNode);
        }
        curNode.next = null;
        curNode = head.next;
        for (int i = 0; i < arr.length; i++) {   // 通过映射关系填充random指针
            curNode.random = mp.get(arr[i][1]);
            curNode = curNode.next;
        }
        return head;
    }

打印不带头节点的随机指针链表

    /**
     * 打印不带头节点的随机指针链表
     *
     * @param head
     */
    public void showNoHeadRandomNextList(Node head) {
        Node curNode = head;
        while (curNode != null) {
            Integer randomVal = curNode.random == null ? null : curNode.random.val;
            System.out.print("[" + curNode.val + " " + randomVal + "] ");
            curNode = curNode.next;
        }
        System.out.println();
    }

法一（哈希）

    /**
     * 法一（哈希）
     * 时间复杂度O(n)
     * 空间复杂度O(n)
     *
     * @param head
     * @return
     */
    public Node copyRandomList(Node head) {
        if (head == null) {
            return null;
        }
        Node curNode = head;
        Map<Node, Node> mp = new HashMap<>(); // 利用hash存储原结点和克隆结点的映射关系
        while (curNode != null) {
            Node copyNode = new Node(curNode.val);
            mp.put(curNode, copyNode);
            curNode = curNode.next;
        }
        curNode = head;
        while (curNode != null) { // 通过映射关系处理克隆结点的next指针和random指针
            mp.get(curNode).next = mp.get(curNode.next);
            mp.get(curNode).random = mp.get(curNode.random);
            curNode = curNode.next;
        }
        return mp.get(head);
    }

本地测试

        /**
         * 138. 复制带随机指针的链表
         */
        lay.showTitle(138);
        Solution138 sol138 = new Solution138();
        Integer[][] arr138 = new Integer[][]{{7, null}, {13, 0}, {11, 4}, {10, 2}, {1, 0}};
        randomNextList.Node head138 = randomNextListOpt.creatRandomNextList(arr138);
        randomNextListOpt.showNoHeadRandomNextList(head138.next);
        randomNextList.Node copyHead138 = sol138.copyRandomList(head138);
        randomNextListOpt.showNoHeadRandomNextList(copyHead138.next);