LeetCode算法题-链表类
1.将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 （可以参照第2的merge2List实现）
示例：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-two-sorted-lists
易错点：
（1）没考虑其中一个是空链表情况
（2）往前插入和往后插入的情况处理没想清楚
最后提交代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def mergeTwoLists(self, l1, l2): """ :type l1: ListNode :type l2: ListNode :rtype: ListNode """ if l1 is None: return l2 if l2 is None: return l1 head = None cur = l1 l2_cur = l2 while l2_cur is not None: l2_cur_tmp = l2_cur.next if cur.val > l2_cur.val: head = l2_cur l2_cur.next = cur cur = l2_cur else: if head is None: head = cur while cur.next is not None and cur.next.val <= l2_cur.val: cur = cur.next l2_cur.next = cur.next cur.next = l2_cur cur = cur.next l2_cur = l2_cur_tmp return head
2.合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。
示例:
输入:
[
1->4->5,
1->3->4,
2->6
]
输出: 1->1->2->3->4->4->5->6
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists
易错点：
（1）比较容易想到第1个和第2个合并，然后再和第3个合并，但这属于暴力破解法了
（2）还容易想到每次比较每个链表的最前面节点调最小的，比较的方法可以使用最小堆
（3）其实好的方法应该是分治思想，比如先每组两两结合，然后4,4结合，以此类推，做到时间复杂度为O(nlgk)
（4）实现merge2List函数使用一个head作为头指针，可使得程序更易读和写
最后提交代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def mergeKLists(self, lists): """ :type lists: List[ListNode] :rtype: ListNode """ list_num = len(lists) interval= 1 while interval < list_num: for i in range(0, list_num - interval, interval * 2): lists[i] = self.merge2Lists(lists[i], lists[i+interval]) interval *= 2 return lists[0] if list_num > 0 else None def merge2Lists(self, l1, l2): pre_cur = head = ListNode(0) cur = l1 head.next = cur while l2 != None: l2_next = l2.next if cur is None or cur.val > l2.val: l2.next = cur pre_cur.next = l2 pre_cur = l2 else: while cur.next != None and l2.val >= cur.next.val: cur = cur.next l2.next = cur.next cur.next = l2 pre_cur = cur cur = cur.next l2 = l2_next return head.next
官方对于merge2Lists有个更优的解放：
def merge2Lists(self, l1, l2): point = head = ListNode(0) while l1 and l2: if l1.val <= l2.val: point.next = l1 l1 = l1.next else: point.next = l2 l2 = l1 l1 = point.next.next point = point.next if l1: point.next = l1 else: point.next = l2 return head.next
优点：当两个链表长度相差较大时，时间复杂度是O( min( l1_len, l2_len ) )
实现思路：
point始终和l1保持在一条链表上，方便判断
3.给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例:
给定 1->2->3->4, 你应该返回 2->1->4->3.
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/swap-nodes-in-pairs
易错点：
（1）两两交换后，没有考虑前面的指向，比如交换了3和4，但却没有把1的指向指向4，导致输出结果为2->1->3，这是我一开始犯的错
（2）增加一个pre指针头部可以让程序逻辑简化
最后提交代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def swapPairs(self, head): """ :type head: ListNode :rtype: ListNode """ pre = ListNode(0) pre.next = head first = head head = pre while first and first.next: second = first.next first.next = second.next second.next = first pre.next = second pre = first first = first.next return head.next
4.给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
示例 :
给定这个链表：1->2->3->4->5
当 k = 2 时，应当返回: 2->1->4->3->5
当 k = 3 时，应当返回: 3->2->1->4->5
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group
易错点和关键点：
（1）首先联系到链表的翻转算法逻辑，每个k个翻转一次就好，最后一个可能不够k，所以遍历时发现不够就再翻转一次即返回之前那样
（2）处理每段k个这里的细节第一版代码处理的很繁琐，这里想了许久，实现思想如下图
当处理完1,2,3,4时，1指向5，但当处理完5,6,7,8时，1应改为指向8
第一版提交代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def reverseKGroup(self, head, k): """ :type head: ListNode :type k: int :rtype: ListNode """ if k <= 0: return None if k == 1: return head pre_list_node = None cur = head head = None while cur != None: ret = self.reverse_k_list(cur, k) if ret == cur: break if pre_list_node != None: pre_list_node.next = ret pre_list_node = cur if not head: head = ret cur = cur.next return head if head else cur def reverse_k_list(self, cur, k): flag = 0 first = cur pre = None while cur and flag < k: flag += 1 l_next = cur.next cur.next = pre pre = cur cur = l_next if flag < k: cur = pre pre = None while flag > 0: flag -= 1 l_next = cur.next cur.next = pre pre = cur cur = l_next else: first.next = cur return pre
经过优化修改后的版本：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def reverseKGroup(self, head, k): """ :type head: ListNode :type k: int :rtype: ListNode """ if k <= 0: return None if k == 1: return head pre_list_node = ListNode(0) cur = head head = pre_list_node while cur != None: ret = self.reverse_k_list(cur, k) pre_list_node.next = ret pre_list_node = cur cur = cur.next return head.next def reverse_k_list(self, cur, k, is_reverse_back=False): flag = 0 first = cur pre = None while cur and flag < k: flag += 1 l_next = cur.next cur.next = pre pre = cur cur = l_next if flag < k: pre = self.reverse_k_list(pre, flag, is_reverse_back=True) else: if not is_reverse_back: first.next = cur return pre
这个版本的优化在于优化了一些繁琐的代码，比如再翻转可以利用原函数，找head更简单，使程序逻辑看上去更清晰
5.给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。
示例 1:
输入: 1->2->3->4->5->NULL, k = 2
输出: 4->5->1->2->3->NULL
解释:
向右旋转 1 步: 5->1->2->3->4->NULL
向右旋转 2 步: 4->5->1->2->3->NULL
示例 2:
输入: 0->1->2->NULL, k = 4
输出: 2->0->1->NULL
解释:
向右旋转 1 步: 2->0->1->NULL
向右旋转 2 步: 1->2->0->NULL
向右旋转 3 步: 0->1->2->NULL
向右旋转 4 步: 2->0->1->NULL
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/rotate-list
关键点和易错点：
（1）这道题思路很简单，一开始想到的就是跟倒数第几个类似的方法，这里多了对k取模操作，但不必通过走到最后一个None才知道哪个是要变头部的，因为我们有整个链表长度了，可以直接计算得到第几个
（2）计算第几个时注意要用l_len-k才是算第几个，否则是倒数的
连接成环再拆思路代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def rotateRight(self, head, k): """ :type head: ListNode :type k: int :rtype: ListNode """ if not head: return head tmp_head = head l_len = 1 while tmp_head.next: l_len += 1 tmp_head = tmp_head.next tmp_head.next = head k = k % l_len k = l_len - k tmp_head = head pre = None while k > 0: pre = tmp_head tmp_head = tmp_head.next k -= 1 pre.next = None head = tmp_head return head
6.给定一个链表，每个节点包含一个额外增加的随机指针，该指针可以指向链表中的任何节点或空节点。
要求返回这个链表的深拷贝。
示例：
输入：
{"$id":"1","next":{"$id":"2","next":null,"random":{"$ref":"2"},"val":2},"random":{"$ref":"2"},"val":1}
解释：
节点 1 的值是 1，它的下一个指针和随机指针都指向节点 2 。
节点 2 的值是 2，它的下一个指针指向 null，随机指针指向它自己。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/copy-list-with-random-pointer
关键点和易错点：
（1）这道题的难点在于处理这个random，常规的方法很容易想到，用一个字典保存原节点对应新节点，然后遍历一遍即可
（2）第一种思路需要使用O(n)的空间，有一种巧妙的解法是O(1)的空间复杂度，但时间复杂度是O(3n)，第一遍遍历复制节点并把新节点放到旧结点的前面，用next指针串起来，然后再遍历一遍处理random指针，最后一遍遍历处理next指针
第一种解法代码：
""" # Definition for a Node. class Node(object): def __init__(self, val, next, random): self.val = val self.next = next self.random = random """ class Solution(object): def copyRandomList(self, head): """ :type head: Node :rtype: Node """ if not head: return None record = {} tmp_head = Node(head.val, None, None) record[head] = tmp_head while head: if head not in record: head2 = Node(head.val, None, None) record[head] = head2 else: head2 = record[head] if head.next: if head.next not in record: head2_next = Node(head.next.val, None, None) record[head.next] = head2_next else: head2_next = record[head.next] head2.next = head2_next if head.random: if head.random not in record: head2_random = Node(head.random.val, None, None) record[head.random] = head2_random else: head2_random = record[head.random] head2.random = head2_random head = head.next return tmp_head
第二种解法代码：
""" # Definition for a Node. class Node(object): def __init__(self, val, next, random): self.val = val self.next = next self.random = random """ class Solution(object): def copyRandomList(self, head): """ :type head: Node :rtype: Node """ if not head: return None ptr = head while ptr: new_node = Node(ptr.val, None, None) new_node.next = ptr.next ptr.next = new_node ptr = new_node.next ptr = head while ptr: if ptr.random: ptr.next.random = ptr.random.next ptr = ptr.next.next ret_head = head.next ptr = head while ptr: old_node = ptr.next ptr.next = old_node.next old_node.next = old_node.next.next if old_node.next else None ptr = ptr.next return ret_head
7.给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
说明：不允许修改给定的链表。
示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：tail connects to node index 1
解释：链表中有一个环，其尾部连接到第二个节点。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/linked-list-cycle-ii
关键点和易错点：
（1）第一步应该判断出是否有环，可以采用快慢指针来找出
（2）根据快慢指针特性列出公式计算出如何找到环的开始点
很明显two_step走的路程肯定是one_step的两倍，所以可列出公式：
2 * D(one_step) = D(two_step)
= 2 (F + a) = F + n(a+b) + a
= F + a = n(a+b)
= F = n(a+b) - (a+b) +b
= F = (n-1)(a+b) + b
由于a+b是一个环路，所以如果从起点和相遇点同时走，这两个指针一定会在起始点相遇
提交代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def detectCycle(self, head): """ :type head: ListNode :rtype: ListNode """ one_step = head two_step = head ptr1 = head ptr2 = None while two_step: if two_step.next and two_step.next.next: two_step = two_step.next.next else: break one_step = one_step.next if one_step == two_step: ptr2 = two_step break if ptr2: while ptr1 != ptr2: ptr1 = ptr1.next ptr2 = ptr2.next return ptr1 return None
8.对链表进行插入排序
插入排序的动画演示如上。从第一个元素开始，该链表可以被认为已经部分排序（用黑色表示）。
每次迭代时，从输入数据中移除一个元素（用红色表示），并原地将其插入到已排好序的链表中。
插入排序算法：
插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。
每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。
重复直到所有输入数据插入完为止。
示例 1：
输入: 4->2->1->3
输出: 1->2->3->4
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/insertion-sort-list
关键点和易错点：
（1）这道题目看着很简单，但其实有几个是很难察觉到的，且不调试很难看出来，花了一个多钟才完成，复习时去重做一遍
（2）head是会变的，这里是个易错点，想当然的tmp_head = t_head.next写成了tmp_head = head，很难察觉
（3）中间插入过程中很容易忘记已排序的最后一个元素的指向应该改为指向在排的下一个元素，因为以前的插入排序是数组，所以没有考虑这个，换成指针这里很难察觉到，就错了，而且很难发现
（4）加上一个tail指针可以优化算法平均时间
提交代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def insertionSortList(self, head): """ :type head: ListNode :rtype: ListNode """ if not head: return head t_head = ListNode(0) t_head.next = head cur = head.next tail = head while cur: cur_next = cur.next tmp_head = t_head.next pre = t_head if tail.val > cur.val: while tmp_head != cur and tmp_head.val <= cur.val: pre = tmp_head tmp_head = tmp_head.next if tmp_head != cur: cur.next = pre.next pre.next = cur tail.next = cur_next else: tail = cur cur = cur_next return t_head.next
9.编写一个程序，找到两个单链表相交的起始节点。
示例 1：
注意：
如果两个链表没有交点，返回 null.
在返回结果后，两个链表仍须保持原有的结构。
可假定整个链表结构中没有循环。
程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/intersection-of-two-linked-lists
易错点和关键点：
（1）有点难想到可以根据路程来解决此题，解题思路是某条链表的走到尾后，再走另外一条链表头开始走，如果有相交的，则它们一定会相遇，因为路程相等，比如上面的图：4-1-8-4-5-5-0-1-8跟5-0-1-8-4-5-5-1-8这两者走的步数是一样的，都是走9步后到的，原理其实就是A+B=B+A
（2）要判断不相交，则可以用最后一个元素来判断，如果不相交最后一个元素肯定是不相同的
提交代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def getIntersectionNode(self, headA, headB): """ :type head1, head1: ListNode :rtype: ListNode """ if not headA or not headB: return None first_tail = None curA = headA curB = headB while True: if curA == curB: return curA if curA.next == None: if first_tail: if first_tail != curA: return None else: first_tail = curA curA = headB else: curA = curA.next if curB.next == None: if first_tail: if first_tail != curB: return None else: first_tail = curB curB = headA else: curB = curB.next
10.给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。
请尝试使用原地算法完成。你的算法的空间复杂度应为 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
关键点和易错点：
（1）这道题本身难度很小，但是要把它写到优雅，这是个难题
（2）用当前偶数节点来作为while里的判断可以保证当前奇数节点一定不是None的，所以节省了很多繁琐判断逻辑
提交代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def oddEvenList(self, head): """ :type head: ListNode :rtype: ListNode """ if not head: return head even = head.next odd_cur = head even_cur = even while even_cur and even_cur.next: odd_cur.next = even_cur.next odd_cur = odd_cur.next even_cur.next = odd_cur.next even_cur = even_cur.next odd_cur.next = even return head
11.给定两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储单个数字。将这两数相加会返回一个新的链表。
你可以假设除了数字 0 之外，这两个数字都不会以零开头。
进阶:
如果输入链表不能修改该如何处理？换句话说，你不能对列表中的节点进行翻转。
示例:
输入: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
输出: 7 -> 8 -> 0 -> 7
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-two-numbers-ii
关键点和易错点：
（1）这道题比较直观的想法是用递归，需要给比较短的那条链表前面插入几个0，使两者长度相同，然后递归回溯相加解决，因为题目说不能改变原始链表，所以要删除掉添加的，如果可以改变原始链表，其实翻转链表更简单
（2）其实可以使用双栈法实现，要注意的就是短的链表在到None时不要插入0填充,，这是我一开始犯的错
（3）往前面填充计算的单元，即头插法
提交代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def addTwoNumbers(self, l1, l2): """ :type l1: ListNode :type l2: ListNode :rtype: ListNode """ stack_l1 = [] stack_l2 = [] while l1 or l2: if l1: stack_l1.append(l1.val) l1 = l1.next if l2: stack_l2.append(l2.val) l2 = l2.next carry_flag = 0 tmp_head = ListNode(0) while len(stack_l1) > 0 or len(stack_l2) > 0: tmp1 = 0 if len(stack_l1) <= 0 else stack_l1.pop(-1) tmp2 = 0 if len(stack_l2) <= 0 else stack_l2.pop(-1) add_result = tmp1 + tmp2 + carry_flag new_node = ListNode(add_result%10) carry_flag = add_result / 10 new_node.next = tmp_head.next tmp_head.next = new_node if carry_flag > 0: new_node = ListNode(carry_flag) new_node.next = tmp_head.next tmp_head.next = new_node return tmp_head.next
12.给出一个以头节点 head 作为第一个节点的链表。链表中的节点分别编号为：node_1, node_2, node_3, ... 。
每个节点都可能有下一个更大值（next larger value）：对于 node_i，如果其 next_larger(node_i) 是 node_j.val，那么就有 j > i 且 node_j.val > node_i.val，而 j 是可能的选项中最小的那个。如果不存在这样的 j，那么下一个更大值为 0 。
返回整数答案数组 answer，其中 answer[i] = next_larger(node_{i+1}) 。
注意：在下面的示例中，诸如 [2,1,5] 这样的输入（不是输出）是链表的序列化表示，其头节点的值为 2，第二个节点值为 1，第三个节点值为 5 。
示例 1：
输入：[2,1,5]
输出：[5,5,0]
示例 2：
输入：[2,7,4,3,5]
输出：[7,0,5,5,0]
示例 3
输入：[1,7,5,1,9,2,5,1]
输出：[7,9,9,9,0,5,0,0]
提示：
对于链表中的每个节点，1 <= node.val <= 10^9
给定列表的长度在 [0, 10000] 范围内
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/next-greater-node-in-linked-list
关键点和易错点：
（1）一看到这题目总让人感觉不简单的样子，然后就想到是不是可以使用归并排序思想来解决，但是链表其实做归并这种思路其实操作很不方便，而且复杂度是O(nlgn)，我一开始就是卡死在这个思路了，正确的方法应该是放弃这个思路，寻找其它思路
（2）其实有点规律在这里面的，假设n-2，n-1都还没找到那个合适的值，已经说明了n-1肯定是比n-2小的，而且没有匹配到的都是这样递减的，是不是可以把匹配到的可以先抽出来，留下未匹配的，只要比较下最前面的未匹配的来决定是否要匹配之前的，这里其实就剪枝了，所以本题使用了一个栈来保存还未匹配的，此方法叫做单栈法
思维图解：
提交代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def nextLargerNodes(self, head): """ :type head: ListNode :rtype: List[int] """ result = [] stack = [] cur = head while cur: result_index = len(result) - 1 while len(stack) > 0 and stack[len(stack)-1] < cur.val: while result[result_index] != 0: result_index -= 1 result[result_index] = cur.val stack.pop(-1) result.append(0) stack.append(cur.val) cur = cur.next return result
13.给你一个单链表的引用结点 head。链表中每个结点的值不是 0 就是 1。已知此链表是一个整数数字的二进制表示形式。
请你返回该链表所表示数字的 十进制值 。
示例 1：
输入：head = [1,0,1]
输出：5
解释：二进制数 (101) 转化为十进制数 (5)
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/convert-binary-number-in-a-linked-list-to-integer
关键点和易错点：
（1）这道题比较直观的是想到链表翻转来计算，但很难跟位运算联系起来（其实遇到0,1就应该往位运算方面去想才是正确的思路），用位运算完美解决此问题，所以很多算法有时就巧在会把知识融会贯通
提交代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def getDecimalValue(self, head): """ :type head: ListNode :rtype: int """ result = 0 while head: result <<= 1 result += head.val head = head.next return result
14.在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。
示例 1:
输入: 4->2->1->3
输出: 1->2->3->4
示例 2:
输入: -1->5->3->4->0
输出: -1->0->3->4->5
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sort-list
关键点和易错点：
（1）看到题目要求的O(nlgn)的时间复杂度，我们就应该联想到快速排序、堆排序和归并排序等，快速排序只是平均时间复杂度是O(nlgn)，最坏情况下是O(n²)，用归并排序是比较方便且时间复杂度满足要求的，中间节点使用快慢指针来查找
（2）这里有个易错点是l1_head = self.sortList(head)，我写成了l1_head = self.sortList(one_step)，提交代码后错误了，看了n遍也没找到这个问题，这是非常容易错且不易发现的问题，传参时一定要谨慎再谨慎
提交代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def sortList(self, head): """ :type head: ListNode :rtype: ListNode """ if not head or not head.next: return head one_step = head two_step = head.next while two_step and two_step.next: one_step = one_step.next two_step = two_step.next.next two_step = one_step.next one_step.next = None l1_head = self.sortList(head) l2_head = self.sortList(two_step) return self.merge(l1_head, l2_head) def merge(self, l1, l2): tmp_head = ListNode(0) cur = tmp_head while l1 and l2: if l1.val <= l2.val: cur.next = l1 l1 = l1.next else: cur.next = l2 l2 = l2.next cur = cur.next if l1: cur.next = l1 else: cur.next = l2 return tmp_head.next
15.给你一个链表的头节点 head，请你编写代码，反复删去链表中由 总和 值为 0 的连续节点组成的序列，直到不存在这样的序列为止。
删除完毕后，请你返回最终结果链表的头节点。
你可以返回任何满足题目要求的答案。
（注意，下面示例中的所有序列，都是对 ListNode 对象序列化的表示。）
示例 ：
输入：head = [1,2,3,-3,-2]
输出：[1]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-zero-sum-consecutive-nodes-from-linked-list
易错点和关键点：
（1）一时很难想到可以使用前缀和来判断
（2）用hashmap来记录
（3）下面代码的while循环那里while delete_node is not head这里一开始想错了，这个是不用del的；还有del时需要判断下该值是否在hash中不然del直接抛异常了
提交代码：
# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def removeZeroSumSublists(self, head): """ :type head: ListNode :rtype: ListNode """ tmp_head = ListNode(0) tmp_head.next = head sum_hash = {} sum_hash[0] = tmp_head pre_sum = 0 while head: total_sum = pre_sum + head.val pre_sum = total_sum if total_sum in sum_hash: tmp = sum_hash[total_sum] delete_node = tmp.next tmp.next = head.next while delete_node is not head: total_sum += delete_node.val if total_sum in sum_hash: del sum_hash[total_sum] delete_node = delete_node.next head = tmp.next else: sum_hash[total_sum] = head head = head.next return tmp_head.next
16.设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。
在链表类中实现这些功能：
get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。
示例：
MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2); //链表变为1-> 2-> 3
linkedList.get(1); //返回2
linkedList.deleteAtIndex(1); //现在链表是1-> 3
linkedList.get(1); //返回3
提示：
所有val值都在 [1, 1000] 之内。
操作次数将在 [1, 1000] 之内。
请不要使用内置的 LinkedList 库。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/design-linked-list
提交代码（双链表实现）：
class ListNode(object): def __init__(self, val): """ Initialize ListNode """ self.val = val self.pre = None self.next = None class MyLinkedList(object): def __init__(self): """ Initialize your data structure here. """ self.list_head = ListNode(0) self.list_len = 0 def get_index_node(self, index): """ Get the index-th node in the linked list, If the index is invaild, return None :type index: int :rtype: ListNode """ if index >= self.list_len or index < 0: return None cur = self.list_head.next while index > 0: index -= 1 cur = cur.next return cur def get(self, index): """ Get the value of the index-th node in the linked list. If the index is invalid, return -1. :type index: int :rtype: int """ node = self.get_index_node(index) if node: return node.val else: return -1 def addAtHead(self, val): """ Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. :type val: int :rtype: None """ tmp = ListNode(val) if self.list_head.next: tmp.next = self.list_head.next self.list_head.next.pre = tmp else: self.list_head.pre = tmp tmp.next = self.list_head self.list_head.next = tmp tmp.pre = self.list_head self.list_len += 1 def addAtTail(self, val): """ Append a node of value val to the last element of the linked list. :type val: int :rtype: None """ tmp = ListNode(val) if self.list_head.next: last_node = self.list_head.pre last_node.next = tmp tmp.pre = last_node tmp.next = self.list_head self.list_head.pre = tmp self.list_len += 1 else: self.addAtHead(val) def addAtIndex(self, index, val): """ Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. :type index: int :type val: int :rtype: None """ if index <= 0: self.addAtHead(val) elif index == self.list_len: self.addAtTail(val) else: pre_node = self.get_index_node(index-1) if pre_node: tmp = ListNode(val) tmp.next = pre_node.next pre_node.next.pre = tmp pre_node.next = tmp tmp.pre = pre_node self.list_len += 1 def deleteAtIndex(self, index): """ Delete the index-th node in the linked list, if the index is valid. :type index: int :rtype: None """ node = self.get_index_node(index) if not node: return None if node.next is self.list_head and node.pre is self.list_head: self.list_head.next = None self.list_head.pre = None elif node.next is self.list_head: node.pre.next = self.list_head self.list_head.pre = node.pre else: node.pre.next = node.next node.next.pre = node.pre self.list_len -= 1
