24 Swap Nodes in Pairs

给定一个链表，交换相邻的元素顺序

1234567

2143657

输入：链表头节点指针

输出：链表头节点指针

思路：交换的话，就是直接互相交换

我的思路就是两遍遍历，第一遍将链表存到vector里面，第二遍进行连接

然后就是分治，将一个链表分为偶数个，然后互相连接？

a->b->c->  假如要交换b、c，那么  保存b，c,    a-> = b->  b-> = c->   c-> = b

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(NULL == head) return NULL;
        vector<ListNode*> nodes;
        auto tempNode = head;
        ListNode* sentinelNode = new ListNode(0);
        sentinelNode->next = head;
        while(tempNode!= NULL){
            nodes.push_back(tempNode);
            tempNode = tempNode->next;
        }
        tempNode = sentinelNode;
        
        //开始对调位置 tempNode:a i:b i+1:c 
        for(int i = 0; i<nodes.size(); i+= 2){
            if(nodes.size() == i+1) break;
            tempNode->next = nodes[i]->next;
            nodes[i]->next = nodes[i+1]->next;
            nodes[i+1]->next = nodes[i];
            tempNode = nodes[i];
        }
        return sentinelNode->next;
    }
};
 

执行用时 : 16 ms, 在Swap Nodes in Pairs的C++提交中击败了9.40% 的用户

内存消耗 : 8.8 MB, 在Swap Nodes in Pairs的C++提交中击败了0.68% 的用户

算法简单，但是比起直接反转的算法，多用了一个存储的时间和存储的空间。

直接方法是递归

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return head;
        auto tempNode = head;
        head = head->next;
        tempNode->next = swapPairs(head->next);
        head->next = tempNode;
        return head;
    }
};
 

执行用时 : 12 ms, 在Swap Nodes in Pairs的C++提交中击败了11.76% 的用户

内存消耗 : 8.9 MB, 在Swap Nodes in Pairs的C++提交中击败了0.68% 的用户

算法简单，效果也好