文章目录
- 1. 题目
- 2. 思路及代码实现(Python)
- 2.1 递归
- 2.2 迭代
1. 题目
给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。
示例 1:
输入:
h
e
a
d
=
[
1
,
2
,
3
,
4
]
head = [1,2,3,4]
head=[1,2,3,4]
输出:
[
2
,
1
,
4
,
3
]
[2,1,4,3]
[2,1,4,3]
示例 2:
输入:
h
e
a
d
=
[
]
head = []
head=[]
输出:
[
]
[]
[]
示例 3:
输入:
h
e
a
d
=
[
1
]
head = [1]
head=[1]
输出:
[
1
]
[1]
[1]
提示:
- 链表中节点的数目在范围 [ 0 , 100 ] [0, 100] [0,100] 内
- 0 < = N o d e . v a l < = 100 0 <= Node.val <= 100 0<=Node.val<=100
2. 思路及代码实现(Python)
2.1 递归
可以通过递归的方式实现两两交换链表中的节点。递归的终止条件是链表中没有节点,或者链表中只有一个节点,此时无法进行交换。如果链表中至少有两个节点,则在两两交换链表中的节点之后,原始链表的头节点变成新的链表的第二个节点,原始链表的第二个节点变成新的链表的头节点。链表中的其余节点的两两交换可以递归地实现。在对链表中的其余节点递归地两两交换之后,更新节点之间的指针关系,即可完成整个链表的两两交换。
用 h e a d head head 表示原始链表的头节点,新的链表的第二个节点,用 n e w H e a d newHead newHead 表示新的链表的头节点,原始链表的第二个节点,则原始链表中的其余节点的头节点是 n e w H e a d . n e x t newHead.next newHead.next。令 h e a d . n e x t = s w a p P a i r s ( n e w H e a d . n e x t ) head.next = swapPairs(newHead.next) head.next=swapPairs(newHead.next),表示将其余节点进行两两交换,交换后的新的头节点为 h e a d head head 的下一个节点。然后令 n e w H e a d . n e x t = h e a d newHead.next = head newHead.next=head,即完成了所有节点的交换。最后返回新的链表的头节点 n e w H e a d newHead newHead。
该算法的时间复杂度取决于链表的节点数 n n n,为 O ( n ) O(n) O(n),空间复杂度取决于递归的栈深为 O ( n ) O(n) O(n)。
class Solution:
def swapPairs(self, head: ListNode) -> ListNode:
if not head or not head.next:
return head
newHead = head.next
head.next = self.swapPairs(newHead.next)
newHead.next = head
return newHead
执行用时:27 ms
消耗内存:16.45 MB
2.2 迭代
也可以通过迭代的方式实现两两交换链表中的节点。
创建哨兵结点 d u m m y H e a d dummyHead dummyHead,令 d u m m y H e a d . n e x t = h e a d dummyHead.next = head dummyHead.next=head。令 t e m p temp temp 表示当前到达的节点,初始时 t e m p = d u m m y H e a d temp = dummyHead temp=dummyHead。每次需要交换 t e m p temp temp 后面的两个节点。
如果 t e m p temp temp 的后面没有节点或者只有一个节点,则没有更多的节点需要交换,因此结束交换。否则,获得 t e m p temp temp 后面的两个节点 n o d e 1 node1 node1 和 n o d e 2 node2 node2,通过更新节点的指针关系实现两两交换节点。
具体而言,交换之前的节点关系是 t e m p − > n o d e 1 − > n o d e 2 temp -> node1 -> node2 temp−>node1−>node2,交换之后的节点关系要变成 t e m p − > n o d e 2 − > n o d e 1 temp -> node2 -> node1 temp−>node2−>node1,因此需要进行如下操作。
t e m p . n e x t = n o d e 2 temp.next = node2 temp.next=node2
n o d e 1. n e x t = n o d e 2. n e x t node1.next = node2.next node1.next=node2.next
n o d e 2. n e x t = n o d e 1 node2.next = node1 node2.next=node1
完成上述操作之后,节点关系即变成 t e m p − > n o d e 2 − > n o d e 1 temp -> node2 -> node1 temp−>node2−>node1。再令 t e m p = n o d e 1 temp = node1 temp=node1,对链表中的其余节点进行两两交换,直到全部节点都被两两交换。
两两交换链表中的节点之后,新的链表的头节点是 d u m m y H e a d . n e x t dummyHead.next dummyHead.next,返回新的链表的头节点即可。该算法的时间复杂度为 O ( n ) O(n) O(n),空间复杂度只需存储固定数量的变量,因此为 O ( 1 ) O(1) O(1)。
class Solution:
def swapPairs(self, head: ListNode) -> ListNode:
dummyHead = ListNode(0)
dummyHead.next = head
temp = dummyHead
while temp.next and temp.next.next:
node1 = temp.next
node2 = temp.next.next
temp.next = node2
node1.next = node2.next
node2.next = node1
temp = node1
return dummyHead.next
执行用时:29 ms
消耗内存:16.42 MB
题解来源:力扣官方题解