Punteros·Nodos
Listas·Enlazadas

// ===== Punteros básicos =====
int x = 42;
int* p = &x;      // p apunta a x

cout << p;          // 0x7FF4  (dirección)
cout << *p;         // 42      (valor)
cout << &x;         // 0x7FF4  (igual)

*p = 99;             // cambia x a 99
cout << x;          // 99 !

// ===== Memoria dinámica =====
int* heap = new int(7); // reserva en heap
cout << *heap;         // 7
delete heap;           // liberar — OBLIGATORIO
heap = nullptr;        // evitar dangling pointer

// Arreglo dinámico
int* arr = new int[5];
arr[0] = 10;
delete[] arr;          // [] para arreglos
arr = nullptr;

// ===== Puntero a struct =====
struct Punto { int x, y; };

Punto pt = {3, 4};
Punto* pp = &pt;

cout << pp->x;          // 3  (flecha = (*pp).x)
cout << (*pp).y;       // 4  (equivalente)

// ===== Definición de un Nodo =====
struct Node {
    int   data;     // el dato almacenado
    Node* next;     // puntero al siguiente

    // Constructor conveniente
    Node(int val) : data(val), next(nullptr) {}
};

// ===== Crear nodos manualmente =====
Node* n1 = new Node(10);
Node* n2 = new Node(20);
Node* n3 = new Node(30);

// Enlazar: 10 → 20 → 30 → null
n1->next = n2;
n2->next = n3;
// n3->next ya es nullptr (constructor)

Node* head = n1;  // cabeza de la lista

// ===== Recorrer la lista =====
Node* curr = head;
while (curr != nullptr) {
    cout << curr->data << " ";
    curr = curr->next;   // avanzar
}
// Output: 10 20 30

// ===== Liberar la lista =====
Node* curr = head;
while (curr != nullptr) {
    Node* tmp = curr;
    curr = curr->next;
    delete tmp;  // liberar ANTES de perder ref
}
head = nullptr;

// ===== Clase LinkedList completa =====
class LinkedList {
private:
    Node* head;

public:
    LinkedList() : head(nullptr) {}

    // Insertar al frente — O(1) ★
    void insertFront(int val) {
        Node* nodo = new Node(val);
        nodo->next = head;
        head = nodo;
    }

    // Insertar al final — O(n)
    void insertEnd(int val) {
        Node* nodo = new Node(val);
        if (!head) { head = nodo; return; }
        Node* curr = head;
        while (curr->next) curr = curr->next;
        curr->next = nodo;
    }

    // Eliminar del frente — O(1)
    void deleteFront() {
        if (!head) return;
        Node* tmp = head;
        head = head->next;
        delete tmp;
    }

    // Buscar un valor — O(n)
    bool search(int val) {
        Node* curr = head;
        while (curr) {
            if (curr->data == val) return true;
            curr = curr->next;
        }
        return false;
    }

    ~LinkedList() { /* liberar nodos */ }
};

// Insertar al frente — O(1)
void insertFront(int val) {
    DNode* n = new DNode(val);
    n->next = head;
    if (head) head->prev = n; // ← actualizar prev
    head = n;
    if (!tail) tail = n;
}

// Eliminar un nodo dado su puntero — O(1) ★
void deleteNode(DNode* node) {
    if (node->prev) node->prev->next = node->next;
    else           head = node->next;
    if (node->next) node->next->prev = node->prev;
    else           tail = node->prev;
    delete node;
}

// Definición con puntero tail en lugar de head
class CircularList {
    Node* tail = nullptr; // apunta al último

public:
    // Insertar al frente — O(1)
    void insertFront(int val) {
        Node* n = new Node(val);
        if (!tail) {
            tail = n;
            n->next = n;  // apunta a sí mismo
        } else {
            n->next = tail->next; // nuevo → head actual
            tail->next = n;   // tail → nuevo
        }
    }

    // Recorrer — detectar fin con puntero inicial
    void print() {
        if (!tail) return;
        Node* curr = tail->next; // head
        do {
            cout << curr->data << " ";
            curr = curr->next;
        } while (curr != tail->next); // volvió
    }
};

// ===== Lista genérica con template =====
template <typename T>
struct Node {
    T       data;
    Node<T>* next;
    Node(T val) : data(val), next(nullptr) {}
};

template <typename T>
class LinkedList {
    Node<T>* head = nullptr;
public:
    void insertFront(T val) {
        Node<T>* n = new Node<T>(val);
        n->next = head;
        head = n;
    }
    // ... demás métodos idénticos
};

// ===== Ejemplo con objetos propios =====
struct Estudiante {
    string nombre;
    double nota;
    Estudiante(string n, double nota)
      : nombre(n), nota(nota) {}
};

LinkedList<Estudiante> curso;
curso.insertFront(Estudiante("Ana", 7.8));
curso.insertFront(Estudiante("Bob", 6.5));

// También funciona con int, string, etc.
LinkedList<int> nums;
LinkedList<string> palabras;