链表 206. 反转链表 147. 对链表进行插入排序 148. 排序链表（归并排序）

206. 反转链表

• 反转一个单链表。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

思路：双指针迭代

1. 申请两个指针pre和cur，将cur指针指向pre，同时将两个指针一起向前移动。
2. 迭代完成时，cur=None，此时pre即为链表头部。
   

代码实现：

class Solution(object):
	def reverseList(self, head):
		pre = None
		cur = head
		# 遍历链表
		while cur:
			# cur.next, pre, cur = pre, cur, cur.next
			
			# 记录当前节点的下一个节点
			tmp = cur.next
			# 然后将当前节点指向pre
			cur.next = pre
			# pre和cur节点都前进一位
			pre = cur
			cur = tmp
			
		return pre	

147. 对链表进行插入排序

• 插入排序算法：
  插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。
  每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。
  重复直到所有输入数据插入完为止。

示例：

示例 1：
输入: 4->2->1->3
输出: 1->2->3->4

示例 2：
输入: -1->5->3->4->0
输出: -1->0->3->4->5

思路：

代码实现：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def helper(self, h, c):
        # 从头开始寻找c的正确位置
        pre = h
        cur = h.next
        while cur.val <= c.val:
            pre = cur
            cur = cur.next
        return pre
    
    def insertionSortList(self, head: ListNode) -> ListNode:
        # 添加一个链表头，处理第一个元素
        h = ListNode(float('-inf'))
        h.next = head
        
        pre = h
        cur = head
        # 插入排序
        while cur:
            # 若已满足排序
            if pre.val <= cur.val:
                pre = cur
                cur = cur.next
                continue
            # 若不满足排序，找到当前元素的正确位置（返回其前一个元素）
            correct_loc = self.helper(h, cur)
            # 将链表重新连接
            pre.next = cur.next
            cur.next = correct_loc.next
            correct_loc.next = cur
            # 进行下一个元素的判断
            cur = pre.next

        return h.next

148. 排序链表（归并排序）

• 在 O(nlogn) 时间复杂度和常数级空间复杂度下，对链表进行排序。

示例：

示例 1:
输入: 4->2->1->3
输出: 1->2->3->4

示例 2:
输入: -1->5->3->4->0
输出: -1->0->3->4->5