每日LeetCode一道题————两两交换链表中的节点

每日一题

题目说明

24.两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例 1：

输入：head = [1, 2, 3, 4]
输出：[2, 1, 4, 3]

示例 2：
输入：head = []
输出：[]

示例 3：
输入：head = [1]
输出：[1]

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/swap-nodes-in-pairs/solution/liang-liang-jiao-huan-lian-biao-zhong-de-jie-di-91/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

算法思路

方法一：迭代

创建一个哑结点dhead (dhead ->next = head),让 tmp 初始时 =dhead，每次交换 tmp 后两个节点。
即 tmp->node1->node2 ---------- tmp->node2->node1
最后让tmp=node1

            tmp->next = Node2;
            Node1->next = Node2->next;
            Node2->next = Node1;
            tmp = Node1;

如果 tmp后两个节点等于NULL ，直接退出。

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution 
{
public:
    ListNode* swapPairs(ListNode* head)
    {
        ListNode* dhead = new ListNode(0);
        dhead->next = head;
        ListNode* tmp = dhead;
        while (tmp->next != NULL && tmp->next->next != NULL)
        {
            ListNode* Node1 = tmp->next;
            ListNode* Node2 = tmp->next->next;
            tmp->next = Node2;
            Node1->next = Node2->next;
            Node2->next = Node1;
            tmp = Node1;
        }
        return dhead->next;
    }
};

复杂度分析

• 时间复杂度：O(n)，其中 n 是链表的节点数量。需要对每个节点进行更新指针的操作。

• 空间复杂度：O(1)。

方法二：递归

用 head 表示原始链表的头节点，新的链表的第二个节点。
用 newHead 表示新的链表的头节点，原始链表的第二个节点，则原始链表中的其余节点的头节点是 newHead.next。
令 head.next = swapPairs(newHead.next)，表示将其余节点进行两两交换，交换后的新的头节点为 head 的下一个节点。
然后令 newHead.next = head，即完成了所有节点的交换。
最后返回新的链表的头节点 newHead。

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

复杂度分析

• 时间复杂度：O(n)，其中 n 是链表的节点数量。需要对每个节点进行更新指针的操作。

• 空间复杂度：O(n)，其中 n 是链表的节点数量。空间复杂度主要取决于递归调用的栈空间。