回文链表和复制复杂链表——链表篇

leetcode 234. 回文链表

题目：

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

示例 1：
输入：head = [1,2,2,1]
输出：true

示例 2：
输入：head = [1,2]
输出：false

提示：
链表中节点数目在范围[1, 105] 内
0 <= Node.val <= 9

进阶：你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

思路1

笔试直接用辅助栈，快速通过。（不过感觉笔试也不会出那么简单的）

代码1:

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        cur = head
        stack = []
        while cur:
            stack.append(cur.val)
            cur = cur.next
        return stack == stack[::-1]

思路2：

利用快慢指针，快指针每次走两步，慢指针每次走一步，快指针走完的时候慢指针来到中间节点。

把中间节点下一个置为None，后半段链表翻转，然后利用前后两个指针进行比较，相等就同时移动两个指针，否则说明结果为False。

最后在返回结果之前把链表还原。这种操作把空间复杂度降到了O（1）。

代码：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        # 用来翻转后半链表
        def reverse(head):
            pre = None
            cur = head
            while cur:
                after = cur.next
                cur.next = pre
                pre = cur
                cur = after
            return pre

        slow, fast = head, head
        while fast.next and fast.next.next:
            slow = slow.next
            fast = fast.next.next

        last = slow.next
        verse_last = reverse(last)
        slow.next = None

        # 前后指针判断
        result = True 
        left, right = head, verse_last
        while left and right:
            if left.val == right.val:
                left = left.next
                right = right.next
            else:
                result = False
                break

        # 还原之前的链表
        slow.next = reverse(verse_last)

        return result

leetcode138. 复制带随机指针的链表

题目：

给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。

构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。

例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。

返回复制链表的头节点。

用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：

val：一个表示 Node.val 的整数。
random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。
你的代码 只 接受原链表的头节点 head 作为传入参数。

示例 1：
输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

示例 2：
输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]

示例 3：
输入：head = [[3,null],[3,0],[3,null]]
输出：[[3,null],[3,0],[3,null]]

思路1：

用哈希，遍历链表，哈希的key是当前节点cur，value是Node(cur.val),存放的是链表结点地址。再遍历一次链表，对于新节点的next和random的指向可以通过哈希表获得。时空复杂度都是O（n）。

代码1：

"""
# Definition for a Node.
class Node:
    def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):
        self.val = int(x)
        self.next = next
        self.random = random
"""

class Solution:
    def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
        # 哈希 老节点：新节点
        if not head:
            return head
        cur = head
        dic = {}
        while cur:
            dic[cur] = Node(cur.val)
            cur = cur.next
        cur = head
        while cur:
            dic[cur].next = dic[cur.next] if cur.next else None
            dic[cur].random = dic[cur.random] if cur.random else None
            cur = cur.next
        return dic[head]

思路2

遍历的时候复制一个新节点放在老节点后面。

新节点的random指向就是老节点random指向的下一个。如1的random指向3，那1’的random指向是3的next也就是3’。

最后分离两个新旧链表，时间复杂度是O（n）,额外空间复杂度是O（1）。

代码2：

"""
# Definition for a Node.
class Node:
    def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):
        self.val = int(x)
        self.next = next
        self.random = random
"""

class Solution:
    def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
        if not head:
            return head
        
        # 复制新节点放在老节点后面
        cur = head
        while cur:
            node = Node(cur.val)
            node.next = cur.next
            cur.next = node
            cur = cur.next.next

        # 确定新节点的random
        cur = head
        while cur:
            cur.next.random = cur.random.next if cur.random else None
            cur = cur.next.next

        # 新老链表分离
        newhead = head.next
        cur = head
        copycur = newhead
        while cur.next and copycur.next:
            cur.next = cur.next.next
            cur = cur.next
            copycur.next = copycur.next.next
            copycur = copycur.next
        cur.next = None
        # copycur.next = None
        return newhead