[leetcode][list] Swap Nodes in Pairs

最新推荐文章于 2022-10-29 12:24:31 发布

原创最新推荐文章于 2022-10-29 12:24:31 发布 · 372 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

171 篇文章

订阅专栏

本文介绍了一种常空间复杂度下交换链表中每对相邻节点的算法，并提供了两种实现方式，一种修改节点值，另一种仅修改节点指针。

题目：

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.

/**
 * 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) {
        if(NULL == head || NULL == head->next) return head;
        ListNode *headNew = head->next;//指向新链表的第一个节点
        ListNode *pFirst = head;//指向本节点对的第一个节点
        ListNode *pSecond = head->next;//指向本节点对的第二个节点
        ListNode *pNext = head->next->next;//指向本节点对的下一个节点
        ListNode *pLast = head;//指向新链表的最后一个节点
        pSecond->next = pFirst;
        while(pNext && pNext->next){
            pFirst = pNext;
            pSecond = pFirst->next;
            pNext = pSecond->next;
            pSecond->next = pFirst;
            pLast->next = pSecond;
            pLast = pFirst;
        }
        if(pNext) pLast->next = pNext;
        else pLast->next = NULL;
        return headNew;
    }
};

以下是无视题目中要求不能修改节点val的版本

/**
 * 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) {
        if(NULL == head || NULL == head->next) return head;
        ListNode *pOdd(head), *pEven(head->next);
        while(pOdd && pOdd->next && pEven->next){//!!!先保证pOdd不为NULL撒
            int iTmp = pOdd->val;//交换两个节点的val
            pOdd->val = pEven->val;
            pEven->val = iTmp;
            pOdd = pOdd->next->next;//更新pOdd
            pEven = pEven->next->next;//更新pEven
        }
        if(NULL == pOdd ->next) return head;//节点个数为奇数
        //节点个数为偶数
        int iTmp = pOdd->val;
        pOdd->val = pEven->val;
        pEven->val = iTmp;
        return head;//节点没变，只是改变了节点的val，所以head没变
    }
};

递归实现：

/**
 * 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) {
	if (NULL == head || NULL == head->next) return head;
	ListNode *p = head->next;
	ListNode *q = p->next;
	p->next = head;
	head->next = swapPairs(q);	
	return p;
}
};