0328.奇偶链表
0234.回文链表
0138.复制带日常的链接表
0328 奇偶链表
给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。
请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)，时间复杂度应为 O(nodes)，nodes 为节点总数。
示例 1:
输入: 1->2->3->4->5->NULL
输出: 1->3->5->2->4->NULL
示例 2:
输入: 2->1->3->5->6->4->7->NULL
输出: 2->3->6->7->1->5->4->NULL
说明:
应当保持奇数节点和偶数节点的相对顺序。
链表的第一个节点视为奇数节点，第二个节点视为偶数节点，以此类推。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/odd-even-linked-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
自己尝试
其实觉得写的还挺满意的，但是超出时间限制了。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def oddEvenList(self, head: ListNode) -> ListNode:
p = head
q = head.next
while p.next and p.next.next:
p.next = p.next.next
q.next = q.next.next
p = p.next
q = q.next
p.next = head.next
return head
学习模仿
看了官方题解，更改后的代码如下：
class Solution:
def oddEvenList(self, head: ListNode) -> ListNode:
if not head:
return head
q = head.next
q1 = q
p = head
while q and q.next:
p.next = q.next
p = p.next
q.next = p.next
q = q.next
p.next = q1
return head
可以看出来，.next.next尽量使用.next代替了，能不用.next就不用。另外在前面加了是否为空链表的判断。其实还是不太明白，很多评论说超时是里面有环了，指向不对，先这样吧，下一题！
0234.回文链表
给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。
示例 1：
输入：head = [1,2,2,1]
输出：true
示例 2：
输入：head = [1,2]
输出：false
提示：
链表中节点数目在范围[1, 105] 内
0 <= Node.val <= 9
这个题直接学习官方解法
方法一：将值复制到数组中后用双指针法
class Solution:
def isPalindrome(self, head: ListNode) -> bool:
vals = []
current_node = head
while current_node is not None:
vals.append(current_node.val)
current_node = current_node.next
return vals == vals[::-1]
时间复杂度：O(n)，其中 n 指的是链表的元素个数。
第一步： 遍历链表并将值复制到数组中，O(n)。
第二步：双指针判断是否为回文，执行了 O(n/2) 次的判断，即O(n)。
总的时间复杂度：O(2n) = O(2n)=O(n)。
空间复杂度：O(n)，其中 n 指的是链表的元素个数，我们使用了一个数组列表存放链表的元素值。
方法二：递归
说实话一知半解，先这样吧，慢慢来，官方有图解的
class Solution:
def isPalindrome(self, head: ListNode) -> bool:
self.front_pointer = head
def recursively_check(current_node=head):
if current_node is not None:
if not recursively_check(current_node.next):
return False
if self.front_pointer.val != current_node.val:
return False
self.front_pointer = self.front_pointer.next
return True
return recursively_check()
方法三：快慢指针
思路
避免使用 O(n) 额外空间的方法就是改变输入。
我们可以将链表的后半部分反转（修改链表结构），然后将前半部分和后半部分进行比较。比较完成后我们应该将链表恢复原样。虽然不需要恢复也能通过测试用例，但是使用该函数的人通常不希望链表结构被更改。
该方法虽然可以将空间复杂度降到 O(1)，但是在并发环境下，该方法也有缺点。在并发环境下，函数运行时需要锁定其他线程或进程对链表的访问，因为在函数执行过程中链表会被修改。
算法
整个流程可以分为以下五个步骤：
找到前半部分链表的尾节点。
反转后半部分链表。
判断是否回文。
恢复链表。
返回结果。
执行步骤一，我们可以计算链表节点的数量，然后遍历链表找到前半部分的尾节点。
我们也可以使用快慢指针在一次遍历中找到：慢指针一次走一步，快指针一次走两步，快慢指针同时出发。当快指针移动到链表的末尾时，慢指针恰好到链表的中间。通过慢指针将链表分为两部分。
若链表有奇数个节点，则中间的节点应该看作是前半部分。
步骤二可以使用「206. 反转链表」问题中的解决方法来反转链表的后半部分。
步骤三比较两个部分的值，当后半部分到达末尾则比较完成，可以忽略计数情况中的中间节点。
步骤四与步骤二使用的函数相同，再反转一次恢复链表本身。
这个思路可以学习到快慢指针把链表一分为二，还调用了206反转链表所用的函数
class Solution:
def isPalindrome(self, head: ListNode) -> bool:
if head is None:
return True
# 找到前半部分链表的尾节点并反转后半部分链表
first_half_end = self.end_of_first_half(head)
second_half_start = self.reverse_list(first_half_end.next)
# 判断是否回文
result = True
first_position = head
second_position = second_half_start
while result and second_position is not None:
if first_position.val != second_position.val:
result = False
first_position = first_position.next
second_position = second_position.next
# 还原链表并返回结果
first_half_end.next = self.reverse_list(second_half_start)
return result
def end_of_first_half(self, head):
fast = head
slow = head
while fast.next is not None and fast.next.next is not None:
fast = fast.next.next
slow = slow.next
return slow
def reverse_list(self, head):
previous = None
current = head
while current is not None:
next_node = current.next
current.next = previous
previous = current
current = next_node
return previous
作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/palindrome-linked-list/solution/hui-wen-lian-biao-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
0138.复制带日常的链接表
学习别人的
递归，不咋能看懂
class Solution:
def copyRandomList(self, head: 'Node') -> 'Node':
Mydic = dict()
def recursion(node: 'Node') -> 'Node':
if node is None: return None
if node in Mydic: return Mydic.get(node)
root = Node(node.val)
Mydic[node] = root
root.next = recursion(node.next)
root.random = recursion(node.random)
return root
return recursion(head)
再看一个
将每个复制插在原来的结点后面
这样做的意义是我们可以通过原random指针的位置，判断新的random指针要指向该random指针的next即可。
在所有random连接好后，我们断开插入的节点，将链表变为原来的连接即可。
"""
# 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: 'Node') -> 'Node':
if not head:
return head
# 复制所有节点，插入原节点的后面
cur = head
while cur:
cur.next = Node(cur.val, cur.next, None)
cur = cur.next.next
# 连接所有复制的节点的random指针
cur = head
copyHead = head.next
while cur:
if cur.random:
cur.next.random = cur.random.next
cur = cur.next.next
# 断开原链表与复制链表之间的连接
cur = head
cur_ = copyHead
while cur and cur_:
cur.next = cur_.next
cur = cur.next
if cur:
cur_.next = cur.next
cur_ = cur_.next
return copyHead