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)
递归迭代都能做,但是看了一下效率,时间上差距不是很大,递归比较省空间。