[Question du jour] Acwing 35. Liste chaînée inversée

sujet

Définissez une fonction, entrez le nœud principal d'une liste liée, inversez la liste liée et sortez le nœud principal de la liste liée après l'inversion.

Questions de réflexion:

Veuillez implémenter les versions itératives et récursives.
Exemple d'
entrée: 1-> 2-> 3-> 4-> 5-> NULL

Sortie: 5-> 4-> 3-> 2-> 1-> NULL

Idées

Regardez l'exemple de la

figure ci - dessous: l'exemple de la figure est clair en un coup d'œil. Comme il s'agit d'une liste liée à un seul lien, nous ne pouvons pas trouver directement le nœud prédécesseur pendant l'itération, nous avons donc besoin d'un pointeur supplémentaire pour enregistrer le nœud prédécesseur. En même temps, avant de changer le pointeur suivant du nœud actuel, n'oubliez pas de sauvegarder ses nœuds successeurs.

Analyse de la complexité de l'espace: il n'y a que 3 variables supplémentaires lors du parcours, donc la complexité de l'espace supplémentaire est O (1) O (1).
Analyse de la complexité temporelle: ne parcourez la liste chaînée qu'une seule fois et la complexité temporelle est O (n) O (n).

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
    
    
public:
    ListNode* reverseList(ListNode* head) {
    
    
        ListNode *pre = nullptr;
        ListNode *cur = head;
        while (cur)
        {
    
    
            ListNode *next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
};

Leetcode 92: Inverser la liste chaînée 2

Donnez-vous la tête de pointeur de la liste liée individuellement et deux entiers à gauche et à droite, où gauche <= droite. Veuillez inverser le nœud de la liste liée de la position gauche à la position droite et revenir à la liste liée inversée.

Exemple 1:
Entrée: tête = [1,2,3,4,5], gauche = 2, droite = 4
Sortie: [1,4,3,2,5]

Idées

Code:

/**
 * 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 {
    
    
private:
    void reverseLinkedList(ListNode *head) {
    
    
        // 也可以使用递归反转一个链表
        ListNode *pre = nullptr;
        ListNode *cur = head;

        while (cur != nullptr) {
    
    
            ListNode *next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
    }
public:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
    
    
        ListNode *dummy = new ListNode(-1);
        dummy->next = head;
        ListNode *pre = dummy;
        for (int i = 0; i < left - 1; ++i)
        {
    
    
            pre = pre->next;
        }

        ListNode *rightNode = pre;
        for (int i = 0; i < right - left + 1; ++i)
        {
    
    
            rightNode = rightNode->next;
        }

        // 截取链表
        ListNode *leftNode = pre->next;
        ListNode *curr = rightNode->next;

        pre->next = nullptr;
        rightNode->next = nullptr;

        reverseLinkedList(leftNode);

        pre->next = rightNode;
        leftNode->next = curr;
        return dummy->next;
    }
};