Práctica guiada sobre listas dobles circulares en C++

Práctica Guiada sobre Listas Dobles Circulares en C++

Introducción a las Listas Dobles Circulares

Las listas dobles circulares son una variación de las listas enlazadas en las que cada nodo tiene un apuntador al siguiente nodo y al nodo anterior, y el último nodo está enlazado al primer nodo formando un círculo. Estas listas permiten recorrer los elementos en ambas direcciones de manera eficiente.

Ventajas de las listas dobles circulares:
- Pueden ser recorridas en ambas direcciones.
- El acceso a los nodos desde cualquier posición es constante.
- La estructura circular permite una navegación continua sin necesidad de manejar condiciones de final de lista.

Implementación de Listas Dobles Circulares en C++

Estructura de un Nodo

Cada nodo en una lista doble circular contiene tres elementos: el dato, un apuntador al siguiente nodo y un apuntador al nodo anterior. A continuación se muestra la estructura de un nodo:

```cpp
struct Node {
   int data;
   Node* next;
   Node* prev;
};
```

Clase para la Lista Doble Circular

La clase para la lista doble circular contiene un apuntador al nodo principal (head). Aquí se muestra la implementación de la clase con operaciones básicas:

```cpp
class DoublyCircularLinkedList {
private:
   Node* head;
public:
   DoublyCircularLinkedList() { head = nullptr; }
   void insert(int value);
   void remove(int value);
   Node* search(int value);
   void display();
};

void DoublyCircularLinkedList::insert(int value) {
   Node* newNode = new Node();
   newNode->data = value;
   if (head == nullptr) {
       head = newNode;
       newNode->next = head;
       newNode->prev = head;
   } else {
       Node* tail = head->prev;
       tail->next = newNode;
       newNode->prev = tail;
       newNode->next = head;
       head->prev = newNode;
   }
}

void DoublyCircularLinkedList::remove(int value) {
   if (head == nullptr) return;
   Node* current = head;
   do {
       if (current->data == value) {
           if (current->next == current) {
               head = nullptr;
           } else {
               current->prev->next = current->next;
               current->next->prev = current->prev;
               if (current == head) head = current->next;
           }
           delete current;
           return;
       }
       current = current->next;
   } while (current != head);
}

Node* DoublyCircularLinkedList::search(int value) {
   if (head == nullptr) return nullptr;
   Node* current = head;
   do {
       if (current->data == value)
           return current;
       current = current->next;
   } while (current != head);
   return nullptr;
}

void DoublyCircularLinkedList::display() {
   if (head == nullptr) return;
   Node* current = head;
   do {
       std::cout << current->data << " ";
       current = current->next;
   } while (current != head);
   std::cout << std::endl;
}
```

...