【LeetCode】24. Swap Nodes in Pairs

题目描述

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.

Your algorithm should use only constant space. You may not modify the values in the list, only nodes itself can be changed.

解题思路

以下提供两种解题思路：

1. 虽然每次交换的是两个节点，但实际上还需要记录前一个节点的父节点，这样才能确保交换后的链接能够保持连续。所以，可以在链表前加一个dummy节点。顺序遍历整个链表，使用一个cnt来记录是否需要进行交换，直接模拟链表的交换过程即可。
2. 每两个节点的交换操作其实都是相同的，所以可以使用递归求解。

AC代码

• 解法一

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* cur = head;
        ListNode* prev;

        ListNode dummy(-1);
        ListNode* first = &dummy;
        first->next = head;

        int cnt = 0;
        while (cur != NULL) {
            // odd number, swap and update
            if (cnt & 1) {
                //swap
                prev->next = cur->next;
                cur->next = prev;
                first->next = cur;
                //update 
                first = prev;
                cur = prev->next;
            } else {
                prev = cur;
                cur = cur->next;
            }
            cnt++;
        }
        return dummy.next;
    }
};

• 解法二

public ListNode swapPairs(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }

        ListNode newhd = head.next;
        head.next = swapPairs(newhd.next);
        newhd.next = head;
        return newhd;
}