lunes 10 febrero 2025

Cómo evitar elementos duplicados en una lista doblemente enlazada en C++

Cuando trabajamos con listas doblemente enlazadas en C++, es importante asegurarnos de que no se agreguen elementos duplicados. Para lograrlo, podemos implementar un método de búsqueda antes de la inserción y evitar que un nodo con el mismo valor se agregue más de una vez.

Solución para evitar duplicados

Para evitar elementos repetidos en la lista doblemente enlazada, debemos modificar el método insertar() para verificar si el dato ya existe antes de agregar un nuevo nodo. Esto se puede hacer implementando una función buscar(int look) que recorra la lista y devuelva true si el elemento ya está presente.

Código corregido

A continuación, te muestro la implementación corregida:

#pragma once
#include <iostream>
#include "Node.h"

using namespace std;

class Lista {
public:
    void insertar(int data);
    bool buscar(int look);
    void imprimir();

    Lista();
    ~Lista();
private:
    Node* head_n;
};

// Método para buscar un valor en la lista
bool Lista::buscar(int look) {
    Node* cur_n = head_n;
    while (cur_n != nullptr) {
        if (cur_n->data == look) {
            return true; // Se encontró el valor en la lista
        }
        cur_n = cur_n->next_n;
    }
    return false; // No se encontró el valor
}

// Método para insertar un nodo en la lista evitando duplicados
void Lista::insertar(int data) {
    // Verificar si el dato ya existe
    if (buscar(data)) {
        cout << "El elemento " << data << " ya existe en la lista." << endl;
        return;
    }

    Node* nwNode = new Node(data);
    
    if (head_n == nullptr) {
        head_n = nwNode;
        return;
    }

    Node* cur_n = head_n;

    while (cur_n->next_n != nullptr && cur_n->data < data) {
        cur_n = cur_n->next_n;
    }

    if (cur_n == head_n) { 
        nwNode->next_n = head_n;
        head_n->prev_n = nwNode;
        head_n = nwNode;
    } 
    else if (cur_n == nullptr) {
        Node* aux = head_n;
        while (aux->next_n != nullptr) {
            aux = aux->next_n;
        }
        aux->next_n = nwNode;
        nwNode->prev_n = aux;
    } 
    else {
        nwNode->next_n = cur_n;
        nwNode->prev_n = cur_n->prev_n;
        cur_n->prev_n->next_n = nwNode;
        cur_n->prev_n = nwNode;
    }
}

Explicación de los cambios

1. Se implementa la función buscar(int look):

Esta función recorre la lista verificando si el valor ya existe.
Si el valor está presente, retorna true; de lo contrario, retorna false.

2. Modificación en insertar(int data):

Antes de agregar un nuevo nodo, se llama a buscar(data).
Si el dato ya existe, se muestra un mensaje y la función termina sin agregarlo.

Ejemplo de uso

int main() {
    Lista miLista;

    miLista.insertar(10);
    miLista.insertar(20);
    miLista.insertar(30);
    miLista.insertar(20); // No se agregará porque ya existe

    return 0;
}

Salida esperada:

El elemento 20 ya existe en la lista.

Conclusión

La mejor manera de evitar elementos repetidos en una lista doblemente enlazada en C++ es implementar una función de búsqueda que verifique la existencia de un valor antes de insertarlo. Con este enfoque, nos aseguramos de mantener la integridad de la lista y evitar datos duplicados.

Etiquetas:

cpp

Creado por:

Jorge García

Fullstack developer