题目:
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
输入：head = []
输出：[]
示例 3：
输入：head = [1]
输出：[1]
java:
```public class LeetCode024 {
static class ListNode {
int val;
ListNode next;
ListNode() {
}
ListNode(int val) {
this.val = val;
}
ListNode(int val, ListNode next) {
this.val = val;
this.next = next;
}
}
//递归
public static ListNode swapPairs(ListNode head) {
if (head == null || head.next == null) {
return head;
}
//获取下一个节点.
ListNode next = head.next;
ListNode newNode = swapPairs(next.next);
next.next = head;
head.next = newNode;
return next;
}
//指针.
public static ListNode swapPairsPointer(ListNode head) {
ListNode dummy = new ListNode(-1);
dummy.next = head;
//头节点.
ListNode pre = dummy;
//临时节点.
ListNode temp;
//需要交换的第一个节点.
ListNode firstNode;
//需要交换的第二个节点.
ListNode secondNode;
while (pre.next != null && pre.next.next != null) {
temp = pre.next.next.next;
firstNode = pre.next;
secondNode = pre.next.next;
pre.next = secondNode;
secondNode.next = firstNode;
firstNode.next = temp;
pre = firstNode;
}
return dummy.next;
}
public static void main(String[] args) {
ListNode node1 = new ListNode(1);
ListNode node2 = new ListNode(2);
ListNode node3 = new ListNode(3);
ListNode node4 = new ListNode(4);
node1.next = node2;
node2.next = node3;
node3.next = node4;
ListNode listNode = swapPairs(node1);
ListNode nodePointer1 = new ListNode(1);
ListNode nodePointer2 = new ListNode(2);
ListNode nodePointer3 = new ListNode(3);
ListNode nodePointer4 = new ListNode(4);
nodePointer1.next = nodePointer2;
nodePointer2.next = nodePointer3;
nodePointer3.next = nodePointer4;
ListNode listNodePointer = swapPairsPointer(nodePointer1);
while (listNode != null) {
System.out.println(listNode.val);
listNode = listNode.next;
}
System.out.println("--------------------");
while (listNodePointer != null){
System.out.println(listNodePointer.val);
listNodePointer = listNodePointer.next;
}
}
}
Go:
type ListNode24 struct {
Val int
Next *ListNode24
}
// 递归.
func Swap(head *ListNode24) *ListNode24 {
if head == nil || head.Next == nil {
return head
}
next := head.Next
swap := Swap(next.Next)
next.Next = head
head.Next = swap
return next
}
// 指针.
func SwapPointer(head *ListNode24) *ListNode24 {
dummy := &ListNode24{
Next: head,
}
pre := dummy
for head != nil && head.Next != nil {
//2 3 4
pre.Next = head.Next
//3->4
next := head.Next.Next
//2->1
head.Next.Next = head
//1->3->4
head.Next = next
//1 3 4
pre = head
//3 4
head = next
}
return dummy.Next
}
func main() {
head := LeetCode.ListNode24{1, &LeetCode.ListNode24{2, &LeetCode.ListNode24{3, &LeetCode.ListNode24{4, nil}}}}
swap := LeetCode.Swap(&head)
headPointer := LeetCode.ListNode24{1, &LeetCode.ListNode24{2, &LeetCode.ListNode24{3, &LeetCode.ListNode24{4, nil}}}}
swapPointer := LeetCode.SwapPointer(&headPointer)
for swap != nil {
fmt.Println("swap:", swap.Val)
swap = swap.Next
}
for swapPointer != nil {
fmt.Println("swapPointer:", swapPointer.Val)
swapPointer = swapPointer.Next
}
}
无声胜有声.
如果大家喜欢我的分享的话.可以关注我的微信公众号
念何架构之路
