C/Visual C - Listas enlazadas simples...

 
Vista:

Listas enlazadas simples...

Publicado por silrodo (2 intervenciones) el 22/06/2001 04:48:49
alquien me puede pasar el algoritmo para eliminar listas enlazadas simples, tengo el siguiente problema debo eliminar todas aquellas que sean iguales a cierto valor, aqui esta el codigo que he puesto...
void Nodo::ElimFila(int fila, int tam)
{
Nodo *S, *Aux;

int cont=0;
Mostrar(tam);
S=P;
int ep=1;

while (S!=NULL)
{ if (S->Fil==fila && ep==1)
{ P=S->SigTer;
ep=0;
}
ep=0;
Aux=S;
S=S->SigTer;
if (S->Fil==fila)
Aux->SigTer=S->SigTer;
}
}
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Eliminación de nodos en una lista enlazada simple

Publicado por Alejandro (1031 intervenciones) el 26/09/2024 23:03:47
Aquí tienes un algoritmo para eliminar nodos de una lista enlazada simple que sean iguales a cierto valor:

1. Crea un puntero auxiliar `prev` y un puntero `current` y apúntalos al primer nodo de la lista enlazada.

2. Verifica si el primer nodo de la lista tiene el valor que deseas eliminar. Si es así, mueve el puntero `P` al siguiente nodo y libera la memoria del nodo original.

3. Mientras `current` no sea nulo, realiza los siguientes pasos:

a. Si el valor del nodo actual (`current->Fil`) es igual al valor que deseas eliminar, actualiza el puntero `prev->SigTer` para que apunte al siguiente nodo (`current->SigTer`), y luego libera la memoria del nodo actual.

b. Si el valor del nodo actual no es igual al valor que deseas eliminar, actualiza el puntero `prev` para que apunte al nodo actual y luego mueve el puntero `current` al siguiente nodo.

4. Al finalizar el bucle, habrás eliminado todos los nodos de la lista enlazada que tengan el valor deseado.

Aquí tienes el código actualizado con el algoritmo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
void Nodo::ElimFila(int fila, int tam)
{
    Nodo *prev = NULL;
    Nodo *current = P;
 
    // Verificar si el primer nodo tiene el valor a eliminar
    if (current != NULL && current->Fil == fila)
    {
        P = current->SigTer; // Mover P al siguiente nodo
        delete current; // Liberar memoria del nodo original
        current = P; // Mover current al siguiente nodo
    }
 
    // Recorrer la lista enlazada
    while (current != NULL)
    {
        // Si el valor del nodo actual es igual al valor a eliminar
        if (current->Fil == fila)
        {
            prev->SigTer = current->SigTer; // Actualizar el puntero previo
            delete current; // Liberar memoria del nodo actual
            current = prev->SigTer; // Mover current al siguiente nodo
        }
        else
        {
            prev = current; // Actualizar el puntero previo
            current = current->SigTer; // Mover current al siguiente nodo
        }
    }
}

Recuerda que este es solo un ejemplo de cómo podrías implementar la eliminación de nodos en una lista enlazada simple. Asegúrate de adaptarlo a tu código y estructura de datos específicos. ¡Buena suerte con tu programa, Silrodo!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar