LintCode 两两交换链表中的节点

1.描述

给一个链表，两两交换其中的节点，然后返回交换后的链表。

样例

给出 1->2->3->4, 你应该返回的链表是 2->1->4->3。

2.分析

假设链表中原有的元素为1->2->3->4->5,那么得到的是2->1->4->3->5,

实质上是把第一第二元素互换，第三第四元素互换，以此类推。如果用一个

数组把这些元素存起来，那么得到的是a[0]、a[1]、a[2]、a[3]、a[4]、a[5],

两两交换的到的数组其中的元素顺序为a[1]、a[0]、a[3]、a[2]、a[5]、a[4],

因此建一个新链表把数组中的元素按照重新排列的顺序从数组中取出相应的节点利用

尾插法插入到链表中，所得链表就为交换后的链表了。这里注意如果元素个数为奇数

最后一个元素是不改变的。

3.代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    /**
     * @param head a ListNode
     * @return a ListNode
     */
    ListNode* swapPairs(ListNode* head) {
        // Write your code here
        ListNode *dummy,*rear;
        dummy=new ListNode(0);
        rear=dummy;
        vector<ListNode*> v;
        ListNode *iter=head;
        while(iter!=NULL)
        {
            v.push_back(iter);
            //cout<<iter->val<<endl;
            iter=iter->next;
        }
        int LEN=v.size();
        //cout<<LEN<<endl;
        int i,j;
        if(LEN==1)
        {
            return head;
            //cout<<rear->val<<endl;
        }
        if(LEN%2==0)//偶数个
        {
            for(j=0,i=0;j<(LEN/2);j++)
            {
                ListNode *r,*s,*t;
                r=new ListNode(v[i]->val);
                s=new ListNode(v[i+1]->val);
                rear->next=s;
                rear=s;
                rear->next=r;
                rear=r;
                i=i+2;
            }
        }
        if(LEN%2==1)
        {
            for(j=0,i=0;j<((LEN-3)/2);j++)
            {
                ListNode *r,*s,*t;
                r=new ListNode(v[i]->val);
                s=new ListNode(v[i+1]->val);
                rear->next=s;
                rear=s;
                rear->next=r;
                rear=r;
                i=i+2;
            }
                ListNode *r,*s;
                r=new ListNode(v[i]->val);
                s=new ListNode(v[i+1]->val);
                rear->next=s;
                rear=s;
                rear->next=r;
                rear=r;
                ListNode *u;
                u=new ListNode(v[i+2]->val);
                rear->next=u;
                rear=u;
        }
        return dummy->next;
        ;
    }
};

4.总结

用一个vector把原链表的节点一一读入，同时得到长度LEN。之后根据LEN的奇偶

下面分为两块操作。如果为偶数是直接循环但如果为奇数最后一个数要拿出来单独考虑。

如1、2、3、4两两交换为2、1、4、3，这里a[2]->next=a[3]。

而1、2、3、4、5两两交换为2、1、4、3、5，a[2]->next=a[4]。因此两种情况循环

语句有所不同，故分为奇数和偶数分别考虑。

注意LEN=1是单独考虑的，如4->NULL两两交换后的到的还是4->NULL，本来

这种情况应该应该归属在LEN为奇数中，但在LEN为奇数的代码中红色代码行用到了v[i+1]，

而只有一个元素时是只有一个v[0]的，因此为防止越界把LEN=1单独拿出来考虑，这样

LEN=1，LEN为偶，LEN为奇就把所有的情况包括了。