leetcode刷题之206.反转链表

leetcode刷题之206.反转链表

• 题目：
  反转一个单链表.
• 示例 :

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

• 进阶：
  你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
• 代码1：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        prev = None
        current = head
        while current:
            next_node = current.next
            current.next = prev
            prev = current
            current = next_node
        head = prev
        return head
# 执行用时 :52 ms, 在所有 Python3 提交中击败了83.84%的用户
# 内存消耗 :14.8 MB, 在所有 Python3 提交中击败了19.68%的用户

• 算法说明：
  设定两个指针，prev表示空指针，current表示当前的头节点，建立循环当current指向最后一个节点时，值为Null，循环结束，循环里面用next_node存储当前节点的下一个节点，然后交换当前节点和下一个节点，将当前节点的指针移动给下一位，继续循环。
  第一次循环：
  （1）第一步：next_node = current.next
  将current.next赋值给next_node变量，next指向了节点2，先将节点2保存起来；
  
  （2）第二步：current.next = prev
  将prev = None赋值给current.next，也就是说将节点1指向了Null；
  
  （3）第三步：prev = current
  将current赋值给了prev，即prev指向节点1；
  
  （4）第四步：current = next_node
  将next_node赋值给current，即current指向了节点2.将节点2设为“头节点”。
  
  第二次循环：
  （1）第一步：next_node = current.next
  将current.next赋值给next_node变量，next指向了节点3，先将节点3保存起来；
  
  （2）第二步：current.next = prev
  将prev = None赋值给current.next，第一次循环中prev指向了节点1，第二次循环中节点2指向了节点1，从而完成了翻转；
  
  （3）第三步：prev = current
  将current赋值给了prev，即prev指向节点2；
  
  （4）第四步：current = next_node
  将next_node赋值给current，即current指向了节点3.将节点3设为“头节点”。
  
  持续循环，完成所有节点的翻转：
  
  完整过程如下：
  
• 代码2：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        if head == None:
            return head
        a =[]
        result = ListNode(None)
        while head != None:
            a.append(head.val)
            head = head.next
        a = a[::-1]
        for i in range(len(a)):
            node = ListNode(a[i])
            if i == 0:
                temp = node
            result.next = node
            result = result.next
        return temp
# 执行用时 :92 ms, 在所有 Python3 提交中击败了7.91%的用户
# 内存消耗 :15.9 MB, 在所有 Python3 提交中击败了14.51%的用户

• 算法说明：
  建立一个列表a，和一个链表result；将head链表中的元素遍历并存储到列表a中，先将列表a翻转，然后将a中的元素逐个添加到链表result中，注意在第一次添加的时候，保存头节点temp = node，然后返回头节点temp。

• 代码3：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        if head == None:
            return head
        result = ListNode(head.val)
        head = head.next
        while head != None:
            result = self.insert(0,head.val,result)
            head = head.next
        return result
    def insert(self,key,value,result): #lian biao cha ru yuan su
        node = ListNode(value)
        node.next = result
        return node
# 执行用时 :60 ms, 在所有 Python3 提交中击败了47.19%的用户
# 内存消耗 :15.7 MB, 在所有 Python3 提交中击败了14.51%的用户

• 算法说明：
  先判断链表是否为空，如果为空，直接返回；建立一个空链表result，让链表result头部指向head的头部，然后将head的指针向后移动一位，即head = head.next；建立当head的头部不为空时的循环，使用insert函数，将head链表的元素逐个插入到新建的链表result的头部，返回result即可。