[Preguntas de pincel de LeetCode] 83. Elimina elementos duplicados en la lista ordenada

Hay una lista vinculada organizada en orden ascendente. Déle el nodo principal de esta lista vinculada. Elimine todos los elementos repetidos para que cada elemento solo aparezca una vez.

Devuelve una lista vinculada de resultados también ordenados en orden ascendente.

Ejemplo 1:

Entrada: cabeza = [1,1,2]
Salida: [1,2]
Ejemplo 2:

Entrada: cabeza = [1,1,2,3,3]
Salida: [1,2,3]

inmediato:

El número de nodos en la lista vinculada está dentro del rango [0, 300]
-100 <= Node.val <= 100 Los
datos de la pregunta aseguran que la lista vinculada se haya organizado en orden ascendente

1 solución convencional

/**
 * 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* deleteDuplicates(ListNode* head) 
    {
        //判断头节点
       if(head == NULL)
       {
           return head;
       }
       //临时变量
       ListNode* temp = head;
       while(temp->next != NULL)
       {
           ListNode* p = temp->next;
           if(temp->val == p->val)
           {
               temp->next = p->next;
               delete p;
           }
           else
           {
               temp = temp->next;
           }
       }
       return head;
    }
};

2 Solución recursiva

Suponiendo que hay una lista enlazada no repetitiva después de la primera, solo hay dos casos para la primera cadena: (1) la primera cadena y la segunda cadena se repiten, (2) la primera cadena y la segunda cadena La cadena no es lo mismo.

Si es (1), elimine la primera cadena directamente;

Si es (2), conecte las cadenas.

/**
 * 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* deleteDuplicates(ListNode* head) 
    {
      if(!head || !head->next)
      {
          return head;
      }
      ListNode* newNode = deleteDuplicates(head->next);

      if(head->val == newNode->val)
      {
          head->next = NULL;
          return newNode;
      }
      else
      {
          head->next = newNode;
          return head;
      }
    }
};

Referencia: https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/submissions/