[Lista enlazada DO 1] Eliminar el elemento de la lista enlazada val

        Hola a todos, bienvenidos a mi blog. Esta pregunta es la primera pregunta sobre la lista de enlaces do, y el blog se actualizará uno tras otro. Si hay algún error, corríjame.

Fuente: https://leetcode.cn/problems/remove-linked-list-elements/description/

tema:

Método 1: Definir punteros anterior y cur (punteros dobles)

analizar:

        Use dos punteros prev y cur para recorrer la lista enlazada. El puntero anterior apunta al nodo anterior del nodo actual y el puntero cur apunta al nodo actual.

En el ciclo while, primero verifique si el valor del nodo actual es igual a val. Si es igual, el nodo debe eliminarse.

Si el valor del nodo actual no es igual a val, actualice prev a cur y actualice cur al siguiente nodo para continuar recorriendo la lista vinculada.

Idea 1: prev no es NULL

• Si prev no es NULL, significa que el nodo actual no es el nodo principal, luego apunte prev-> junto al siguiente nodo del nodo actual, luego libere la memoria del nodo actual cur y actualice cur a prev-> next, que es el siguiente nodo a comprobar.

Idea 2: anterior es NULL

• Si prev es NULL, significa que el nodo actual es el nodo principal, luego actualice cur para que sea el siguiente nodo del nodo principal, libere la memoria del nodo principal head y actualice head al nuevo nodo principal cur .

Finalmente, devuelva el encabezado del puntero de la lista enlazada actualizada .

El propósito de este código es eliminar todos los nodos cuyo valor es val en la lista enlazada y liberar la memoria correspondiente al mismo tiempo.

Código: 

struct ListNode* removeElements(struct ListNode* head, int val)
{
	struct ListNode* prev = NULL, * cur = head;
	while (cur)
	{
		if (cur->val == val)
		{
			if (prev)
			{
				prev->next = cur->next;
				free(cur);
				cur = prev->next;
			}
			else
			{
				cur = head->next;
				free(head);//会把指针域next给free掉，因为它也是结构体的成员
				head = cur;
			}
		}
		else
		{
			prev = cur;
			cur = cur->next;
		}
	}
	return head;
}

implementar:

Método 2: Inserción final de lista enlazada

Idea general:

Elimine todos los nodos cuyo valor sea val en la lista vinculada y use el método de inserción de cola para crear una nueva lista vinculada y devuelva el puntero principal de la nueva lista vinculada. Los nodos que no cumplan las condiciones de la lista enlazada original se conservarán y los nodos que cumplan las condiciones se eliminarán y se liberará la memoria.

La idea del tapón de cola:

La función utiliza tres punteros cur, newhead y tail para atravesar y construir una nueva lista enlazada.

En el ciclo while, primero verifique si el valor del nodo actual es igual a val . Si no es igual a val , se realiza la operación de inserción de la cola para agregar el nodo a la nueva lista vinculada.

orden:

1. Si tail es NULL, significa que el nodo actual es el primer nodo de la nueva lista enlazada. Apunte tanto la cabeza nueva como la cola al nodo actual actual .
2. A continuación, actualice cur al siguiente nodo y configure tail->junto a NULL para asegurarse de que la nueva lista vinculada esté desconectada
3. 此时 tail Si no es NULL, significa que el nodo actual debe agregarse al final de la nueva lista vinculada. Señale tail->next al nodo actual  cur , luego actualice tail a tail->next , y vincule la nueva lista vinculada para realizar la inserción de cola .
4. Luego continúa la operación de 2

Si el valor del nodo actual es igual a val, el nodo debe eliminarse. Actualice cur al siguiente nodo y libere la memoria del nodo actual del.

Por último, devuelve el puntero de cabecera newhead de la nueva lista enlazada

dibujo:

Código:

//尾插
struct ListNode* removeElements(struct ListNode* head,int val)
{
  struct ListNode*cur=head;
  struct ListNode *newhead=NULL,*tail=NULL;
 while(cur)
{
    if(cur->val!=val)
    {
      if(tail==NULL)
        {
			newhead=tail=cur;
		}
    	else
		{
     	    tail->next=cur;
     		tail=tail->next;
		}
     		cur=cur->next;//  这两条语句不可以调换顺序，否则tail->next=null
		 	tail->next=NULL;//cur=cur->next，这样写的话会尾插失败
		}
     else
	{
       struct ListNode*del=cur;
       cur=cur->next;
       free(del);//会把指针域next给free掉，因为它也是结构体的成员
	}
 }
 		return newhead;
 }

Ejecución de código:

         Bueno, el blog será compartido aquí, ¡gracias por tu visita!