Given a linked list, swap every two adjacent nodes and return its head.

For example,

Given 1->2->3->4, you should return the list as 2->1->4->3.

给定一个链表,交换每两个相邻的节点,并返回它的头节点。

例:
链表:1->2->3->4,你能得到2->1->4->3链表.

源代码

代码

1
2
3
4
5
6
7
8
class ListNode {
var val: Int
var next: ListNode?
init(_ val: Int,next: ListNode?) {
self.val = val
self.next = next
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
class Solution {
//输出链表
func showList(head: ListNode) {
var printStr: String = ""
var first = head.next
while (first != nil) {
if first!.next != nil {
printStr = printStr.appending("\(first!.val)->")
}else
{
printStr = printStr.appending("\(first!.val)")
}
first = first!.next
}
let firstStr = String(head.val)
guard printStr != "" else {
print(firstStr)
return
}
printStr = firstStr.appending("->\(printStr)")
print(printStr)
}
//交换相邻节点
func swapPairs(_ head: ListNode?) -> ListNode? {
var h = head
var current = head
var f: ListNode?
var s: ListNode?
if head == nil {
return nil
}
if head?.next == nil {
return head
}
// 1->2->3->4->5->6
//1.
let temp = current?.next
//2.
current?.next = (temp?.next)!
//3.
temp?.next = current!
//4.
h = temp
//5.
while current?.next != nil && current?.next?.next != nil {
//6.
f = current?.next
s = f?.next
//7.
current?.next = s
//8.
f?.next = s?.next
//9.
s?.next = f
//10.
current = f
}
return h
}
}
  1. 获取到刚开始的节点 如获取节点2: 1 -> 2
  2. 将1的节点换成2后边的节点 如 1->3->4->5->6
  3. 将2的节点换成1 如 2->1->3->4->5->6
  4. 将2做为头节点
  5. 通过判断位置的节点的后节点和再后节点 如:判断列表 2->1->3->4->5->6 节点的3.4节点是否存在
  6. 存在即开始替换. 将3,4 节点进行替换,我们都知道如果替换两个值得话,要使用临时成员变量来记录
  7. 将当前节点的下一个节点先赋值 如 2->1->4->5->6
  8. 将4的下一个节点5改为3的下一个节点 如 2->1->4 3->5->6
  9. 当前4节点的下一个节点的改为3 如 2->1->4->3->5->6
  10. 重新设置当前的节点为3,开始排序5,6节点