Leetcode 24 ：Swap Nodes in Pairs

原创于 2016-07-31 11:49:17 发布 · 250 阅读

0 ·

CC 4.0 BY-SA版权

Leetcode 专栏收录该内容

4 篇文章

订阅专栏

本文介绍了一种在链表中交换每对相邻节点的算法实现。该算法仅使用常数空间，通过调整指针指向来完成节点交换，而不改变节点内的数值。文中提供了两种不同的C++实现方式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目大意：给定一个链表，交换其中相邻的2个元素

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.

Subscribe to see which companies asked this question

/**
 * 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(head == NULL) return NULL;
        
        if(head != NULL && head->next == NULL) return head;
        
        ListNode* headF = new ListNode(0);
        headF->next = head;
        
        ListNode* headO = headF;
        while(headO->next != NULL && headO->next->next != NULL)
        {
            //
            ListNode* tmpN1 = headO->next->next->next;

            ListNode* tmpN = headO->next;
            
            headO->next = headO->next->next;
            
            headO->next->next = tmpN;
            
            headO->next->next->next = tmpN1;
            
            headO = headO->next->next;
        }
        
        ListNode*Re = headF->next;
        
        delete headF;
        
        return Re;
    }
};

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        bool first = true;
        ListNode *pFirst = head, *pSecond = NULL, *pTail = NULL, *ret = head;
        while (pFirst && pFirst -> next) {  // 判断是否存在两个后继元素
            pSecond = pFirst -> next;       // 获取pSecond
            if (first) ret = pSecond;       // 处理链表头
            if (!first) pTail -> next = pSecond;    // 处理链表中段
            pFirst -> next = pSecond -> next;   
            pSecond -> next = pFirst;       // 交换元素
            pTail = pFirst;                 // 更新链表末尾
            
            pFirst = pFirst -> next;        // 进行到下一个元素
            first = false;
        }
        return ret;
    }
};