24. Swap Nodes in Pairs (Python)

Medium

Given a linked list, swap every two adjacent nodes and return its head. You must solve the problem without modifying the values in the list's nodes (i.e., only nodes themselves may be changed.)

Example 1:

Input: head = [1,2,3,4]
Output: [2,1,4,3]

Example 2:

Input: head = []
Output: []

Example 3:

Input: head = [1]
Output: [1]

Constraints:

• The number of nodes in the list is in the range [0, 100].
• 0 <= Node.val <= 100

又浪费时间，又浪费空间，但是省脑子：

# 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
        """
        if head == None or head.next == None:
            return head
        
        fast = copy.deepcopy(head).next
        slow = copy.deepcopy(head)
        
        
        res = ListNode(0)
        res.next = head
        cur = res
        
        while fast != None :
            
            cur.next = ListNode(fast.val)
            cur.next.next = ListNode(slow.val)
            if fast.next == None:
                break
            
            fast = fast.next.next
            slow = slow.next.next

            cur = cur.next.next
        
        if slow != None and fast != None:
            cur.next = ListNode(fast.val)
            cur.next.next = ListNode(slow.val)
            return res.next
        if slow != None:
            cur.next = ListNode(slow.val)
            return res.next
        
        
        return
    

逻辑就是不是交换，而是按照其他链表题一样，搞两个链表，然后一个走两步（走得快的，fast），一个走一步（走得慢的，slow）。

在原来的顺序里，应该先看到走得慢的，再看到走得快的，因为交换，所以先把走的快的加入链表，再把走的慢的加入链表（这个先后指的是位置，也就是slow fast变成fast slow）

递归迭代都能做，但是看了一下效率，时间上差距不是很大，递归比较省空间。