leetcode.24. Échangez les nœuds de la liste liée par paires (swap-nodes-in-pairs)

Échangez les nœuds de la liste liée par paires (swap-nodes-in-pairs)

Étant donné une liste chaînée, permutez tous les deux nœuds adjacents et renvoyez sa tête.

Vous ne pouvez pas modifier les valeurs des nœuds de la liste. Seuls les nœuds eux-mêmes peuvent être modifiés.

Exemple 1:

Input: head = [1,2,3,4]
Output: [2,1,4,3]

Exemple 2:

Input: head = []
Output: []

Exemple 3:

Input: head = [1]
Output: [1]

Code et idées

Itération

À partir du nœud officiel de swap-nodes-in-pairs (swap-nodes-in-pairs) dans la liste d'échange par paires.

Ici, un nœud factice est défini, node1 et node2 sont obtenus, tempet ils sont échangés, et le pointeur avance. Notez que la condition de terminaison est tempnon seulement derrière un nœud ou des nœuds, plus aucun nœud n'a besoin d'échanger, mettant ainsi fin à l'échange. Lors de l'itération, il est très important de penser clairement à la condition de terminaison.

class Solution {
    
    
public:
    ListNode* swapPairs(ListNode* head) {
    
    
    	//定义一个哑节点
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* temp = dummyHead;
        while (temp->next != nullptr && temp->next->next != nullptr) {
    
    
        	//准备待交换的节点
            ListNode* node1 = temp->next;
            ListNode* node2 = temp->next->next;
            //交换
            temp->next = node2;
            node1->next = node2->next;
            node2->next = node1;
            //移动指针
            temp = node1;
        }
        //返回
        return dummyHead->next;
    }
};

Récursivité (un peu difficile)

    public ListNode swapPairs(ListNode head) {
    
    
        //边界条件判断
        if (head == null || head.next == null)
            return head;
        //从第3个链表往后进行交换
        ListNode third = swapPairs(head.next.next);
        //从第3个链表往后都交换完了，我们只需要交换前两个链表即可,
        //这里我们把链表分为3组，分别是第1个节点，第2个节点，后面
        //的所有节点，也就是1 → 2 → 3，我们要把它变为2 → 1 → 3
        ListNode second = head.next;
        head.next = third;			//你可能会觉得，这里不是指向1吗
        second.next = head;
        
        return second;
    }

Description head.next = third;Vous vous demandez peut-être, ce n'est pas le point vers 1le nœud qu'il, pourquoi est pointé 3, attention, ici un peu différent avec l'approche itérative, nous retournons un nouveau nœud d'en-tête, il est appelé second. Donc, nous avons utilisé secondpour connecter le nœud suivant, vous pouvez également ajuster le format du code, comme ce look.

        			  head.next = third;
        second.next = head;

En d'autres termes second -> head -> third.

Chez sdwwld

autre

Définition de ListNode

  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) {}
  };