《leetCode》：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.

题目大意：对一个链表，以两个相邻的节点为一组进行交换位置，并返回新的头结点。
其中，算法只允许使用常数个内存空间，并且不能够通过改变节点的value来完成这种节点的交换，只能改变结点的指针的指向来完成此功能。

思路

思路：由于有空间的限制，因此，我们不能够将其以两个节点为一组，然后将其翻转，然后储存新的头结点，最后将其连接起来。

这里的思路比较简单：就是改变结点的指向即可完成。

            //先改变两个节点的指向
            nextNode->next=cur;
            cur->next=nextNextNode->next;
            //更新当前结点、和下一个节点；即为完成下两个节点的指针指向做准备。
            cur=nextNextNode;
            nextNode=nextNextNode->next;
            nextNextNode=nextNextNode->next->next; 

完成实现代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* swapPairs(struct ListNode* head) {
    if(head==NULL){
        return NULL;
    }
    if(head->next==NULL){//只有一个节点的情况 
        return head;
    } 
    struct ListNode *cur=head;
    struct ListNode *nextNode=cur->next;
    head=nextNode;//保存新的头结点。 
    struct ListNode *nextNextNode=cur->next->next;
    while(nextNode!=NULL){
        if(nextNextNode!=NULL&&nextNextNode->next!=NULL){
            nextNode->next=cur;
            cur->next=nextNextNode->next;
            cur=nextNextNode;
            nextNode=nextNextNode->next;
            nextNextNode=nextNextNode->next->next; 
        }
        else{//只剩下最后两个节点
            //将cur和cur->next交换就可以了
            nextNode->next=cur;
            cur->next=nextNextNode;//如果是奇数个结点，则最后一个nextNextNode为最后一个节点，为偶数个点，则最后一个nextNextNode为NULL； 
            break; //此时由于后面没有节点了，因此退出就可以了。 

        }

    }
    return head; 
}

遇到的问题

1、在最后两个节点完成交换后没有退出while循环。

解决方法：在最后两个节点完成交换后用break退出即可。

最后的AC结果如下：

从结果可以看出，虽然AC了，但是和别人提交的相比效率并不高，但是至于为什么不高，我也不太清楚。因为这种方法的时间复杂度为O(n),难道还有更快的？？可能的原因是用其他语言来完成，可能会更快吧

这个题属于将链表的K个节点为一组进行翻转的特例。因此我们也可以用K个节点为一组的思路来做。实现代码如下：

struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* reverseList(struct ListNode *head,struct ListNode* last){
    struct ListNode * cur = head;
    struct ListNode * pre = NULL;
    struct ListNode* next = NULL;
    while(cur!=NULL){
        next = cur->next;
        cur->next = pre;
        pre = cur;
        cur = next;
    }
    last->next = pre;
    return head;
}
struct ListNode* swapPairs(struct ListNode* head) {
    if(head==NULL){
        return NULL;
    }
    if(head->next==NULL){//只有一个节点的情况 
        return head;
    } 
    int k =2;
    int count = 0;
    struct ListNode* newHead = (struct ListNode*) malloc(sizeof(struct ListNode));
    newHead->next = head;
    struct ListNode* cur = head;
    struct ListNode* last = newHead;
    struct ListNode* next = NULL;
    while(cur!=NULL){
        count++;
        if(count==k){
            next = cur->next;
            cur->next = NULL;
            last = reverseList(last->next,last);
            last->next = next;
            cur = next;
            count = 0;
        }
        else{
            cur = cur->next;
        }
    }
    return newHead->next;
}  

AC效率比第一种方法要好点。