每日算法总结——链表大于/小于/等于划分、含有随机节点链表的复制

一、 将单链表按照某值划分成左边小、中间相等、右边大的形式

【题目】给定一个单链表的头节点head，节点的值类型是整型，再给定一个整数pivot。实现一个调整链表的函数，将链表调整为左部分都是值小于pivot的节点，中间部分都是值等于pivot的节点，右部分都是值大于pivot的节点。
【进阶】在实现原问题功能的基础上增加如下的要求
【要求】调整后所有小于pivot的节点之间的相对顺序和调整前一样
【要求】调整后所有等于pivot的节点之间的相对顺序和调整前一样
【要求】调整后所有大于pivot的节点之间的相对顺序和调整前一样
【要求】时间复杂度请达到$O(N)$，额外空间复杂度请达到$O(1)$。

方法一、数组快排

思路：将链表所有节点放入数组（Node[]）中，对数组执行快速排序，排完之后，将数组中各个节点依次串起来。

时间复杂度$O(N)$，额外空间复杂度为$O(N)$

public static Node listPartition1(Node head, int pivot) {
    if (head == null) {
        return head;
    }
    Node cur = head;
    int i = 0;
    // 获取大小
    while (cur != null) {
        i++;
        cur = cur.next;
    }
    Node[] nodeArr = new Node[i];
    cur = head;
    for (Node node : nodeArr) {
        node = cur;
        cur = cur.next;
    }
    arrPartition(nodeArr, pivot);
    // 串起来
    for (i = 1; i < nodeArr.length; i++) {
        nodeArr[i - 1].next = nodeArr[i];
    }
    nodeArr[i - 1].next = null;
    return nodeArr[0];
}

public static void arrPartition(Node[] arr, int p) {
    int i = 0, p1 = 0, p2 = arr.length - 1;
    while (i <= p2) {
        if (arr[i].value < p) {
            swap(arr, i++, p1++);
        } else if (arr[i].value > p) {
            swap(arr, i, p2--);
        } else {
            i++;
        }
    }
}

public static void swap(Node[] arr, int src, int dest) {
    Node temp = arr[src];
    arr[src] = arr[dest];
    arr[dest] = temp;
}

方法二、记录各个区域的头尾节点

思路：利用六个变量（小于区头指针、小于区尾指针、等于区头指针、等于区尾指针、大于区头指针、大于区尾指针）对链表的每个节点进行Partition，最后依次将三个区域首位相接，需要注意小于区/等于区/大于区为空的情况

时间复杂度$O(N)$，空间复杂度$O(1)$

public static Node listPartition2(Node head, int pivot) {
    // small head/tail
    Node sH = null;
    Node sT = null;
    // equal head/tail
    Node eH = null;
    Node eT = null;
    // big head/tail
    Node mH = null;
    Node mT = null;

    Node next = null;
    while (head != null) {
        next = head.next;
        head.next = null;
        if (head.value < pivot) {
            if (sH == null) {
                sH = head;
                sT = head;
            } else {
                sT.next = head;
                sT = sT.next;
            }
        } else if (head.value == pivot) {
            if (eH == null) {
                eH = head;
                eT = head;
            } else {
                eT.next = head;
                eT = eT.next;
            }
        } else {
            if (mH == null) {
                mH = head;
                mT = head;
            } else {
                mT.next = head;
                mT = mT.next;
            }
        }
        head = next;
    }
    // 如果有小于区域
    if (sT != null) {
        sT.next = eH;
        // 下一步，谁去连大于区域的头，谁就变成eT
        eT = eT == null ? sT : eT;
    }
    // 上面的if，不管跑了没有，et
    if (eT != null) {
        eT.next = mH;
    }
    return sH != null ? sH : (eH != null ? eH : mH);
}

二、 复制含有随机指针节点的链表

【题目】一种特殊的单链表节点类描述如下

class Node{
    int value;
    Node next ;
    Node rand ;
    Node(int val) {
        value = val;
    }
}

rand指针是单链表节点结构中新增的指针，rand可能指向链表中的任意一个节点，也可能指向null。给定一个由Node节点类型组成的无环单链表的头节点head，请实现一个函数完成这个链表的复制，并返回复制的新链表的头节点。
【要求】时间复杂度0(N)，额外空间复杂度0(1)

方法一：使用哈希表

思路：利用HashMap，key存储原始链表节点，value存储新链表的节点，分两次遍历，第一次遍历只把新旧节点放入map中，第二次遍历拷贝rand和next。

public static Node copyListWithRand1(Node head) {
    Map<Node, Node> map = new HashMap<>();
    // 首先进行节点的拷贝
    Node cur = head;
    while (cur != null) {
        map.put(cur, new Node(cur.value));
        cur = cur.next;
    }
    cur = head;
    // 进行next和rand节点的拷贝
    while (cur != null) {
        map.get(cur).next = map.get(cur.next);
        map.get(cur).rand = map.get(cur.rand);
        cur = cur.next;
    }
    return map.get(head);
}

方法二、不使用哈希表

思路：把克隆出来的节点放在老链表节点的下一个（next），然后由克隆出来的节点串上老链表节点的下一个，遍历对应节点进行rand的拷贝，最后在next方向上把新老链表分离出来。

优点：可以不使用哈希表，只在链表本身上进行复制。

public static Node copyListWithRand2(Node head) {
    if (head == null) {
        return head;
    }
    // 首先对旧节点进行复制，得到的新节点放在旧节点的后面
    Node cur = head;
    Node next;
    while (cur != null) {
        next = cur.next;
        cur.next = new Node(cur.value);
        cur.next.next = next;
        cur = next;
    }
    // 复制rand
    cur = head;
    while (cur != null) {
        cur.next.rand = cur.rand != null ? cur.rand.next : null;
        cur = cur.next.next;
    }
    // 拆分新旧节点
    Node newHead = head.next;
    cur = head;
    next = newHead;
    while (cur != null) {
        cur.next = next.next;
        next.next = cur.next != null ? cur.next.next : null;
        cur = cur.next;
        next = next.next;
    }
    return newHead;
}