Domina las Estructuras
de Datos

letras = ["A", "B", "C"]

# O(1) -> Acceso directo en memoria contigua
primero = letras[0]

# O(n) -> El .insert(0) es muy ineficiente en grandes volúmenes
letras.insert(0, "Z")

// NOTA: Arrays.asList es solo un atajo de Java para no hacer .add() 3 veces.
// Lo verdaderamente importante es que ArrayList maneja la memoria por nosotros.
ArrayList<String> letras = new ArrayList<>(Arrays.asList("A", "B", "C"));

// O(1) -> Salto de memoria matemático directo
String primero = letras.get(0);

// O(n) -> ¡Desplazamiento traumático!
letras.add(0, "Z");

class Nodo:
    def __init__(self, valor, siguiente=None):
        self.valor = valor
        self.siguiente = siguiente

# Replicando el diagrama A -> B -> C
nodoC = Nodo("C")
nodoB = Nodo("B", nodoC)
nodoA = Nodo("A", nodoB)

# O(1) -> La memoria es dispersa, solo enlazamos la flecha
nodoZ = Nodo("Z", nodoA)

class Nodo {
    String valor;
    Nodo siguiente;
    
    public Nodo(String v, Nodo s) {
        valor = v;
        siguiente = s;
    }
}

// Instanciamos al revés para que cada flecha apunte al que ya existe
Nodo nodoC = new Nodo("C", null);
Nodo nodoB = new Nodo("B", nodoC);
Nodo nodoA = new Nodo("A", nodoB);

// Inserción O(1) en O(1)
Nodo nodoZ = new Nodo("Z", nodoA);

class Pila:
    def __init__(self):
        self.items = [] # Array subyacente

    def push(self, plato):
        self.items.append(plato) # O(1)

    def pop(self):
        return self.items.pop() # O(1)

miPila = Pila()
miPila.push("Plato 1")
miPila.push("Plato 2")
miPila.push("Plato 3")
miPila.pop() # Saca "Plato 3"

// Java ya tiene una clase Stack nativa, pero así se construiría
class Pila {
    private ArrayList<String> items = new ArrayList<>();

    public void push(String plato) { items.add(plato); }
    // size() - 1 porque el primer elemento de un Array siempre es el índice 0
    public String pop() { return items.remove(items.size() - 1); }
}

Pila miPila = new Pila();
miPila.push("Plato 1");
miPila.push("Plato 2");
miPila.push("Plato 3");
miPila.pop(); // Saca "Plato 3"

# En Python, los diccionarios (dict) son Hash Tables altamente optimizados
usuarios = {}

# O(1) Inserción
usuarios["Ana"] = "Programadora"
usuarios["Bob"] = "Diseñador"

# O(1) Búsqueda inmediata sin iterar
rol_de_ana = usuarios["Ana"] # "Programadora"

// Java tiene HashMap, la implementación clásica de la estructura
HashMap<String, String> usuarios = new HashMap<>();

// MÁGIA OCULTA: .put() ejecuta la batidora matemática (hashCode) por debajo.
// Si "u_123" y "u_999" chocan, Java crea la Lista Enlazada por ti automáticamente.
usuarios.put("Ana", "Programadora");
usuarios.put("Bob", "Diseñador");

// O(1) Búsqueda directa
String rolDeAna = usuarios.get("Ana"); // "Programadora"

class TreeNode:
    def __init__(self, valor):
        self.valor = valor
        self.izquierdo = None
        self.derecho = None

# El diagrama en código Python
raiz = TreeNode(10)
raiz.izquierdo = TreeNode(5)
raiz.derecho = TreeNode(15)
raiz.izquierdo.izquierdo = TreeNode(3)
raiz.izquierdo.derecho = TreeNode(7)
raiz.derecho.izquierdo = TreeNode(12)
raiz.derecho.derecho = TreeNode(20)

class TreeNode {
    int valor;
    TreeNode izquierdo;
    TreeNode derecho;

    public TreeNode(int v) {
        valor = v;
    }
}

TreeNode raiz = new TreeNode(10);
raiz.izquierdo = new TreeNode(5);
raiz.derecho = new TreeNode(15);
raiz.izquierdo.izquierdo = new TreeNode(3);
raiz.izquierdo.derecho = new TreeNode(7);
raiz.derecho.izquierdo = new TreeNode(12);
raiz.derecho.derecho = new TreeNode(20);

# En Python usamos un simple Dictionary de Listas
red_social = {
    "Ana": ["Bob", "Eva", "Fran", "Carlos", "Zelda"],
    "Fran": ["Bob", "Ana", "Carlos"],
    "Zelda": ["Carlos", "Ana", "Eva", "Mía"],
    "Bob": ["Ana", "Fran"],
    "Eva": ["Ana", "Zelda", "Luis"],
    "Luis": ["Eva"],
    "Carlos": ["Ana", "Fran", "Zelda"],
    "Mía": ["Zelda"]
}

// En Java usamos HashMap donde la llave es String y el valor un ArrayList
HashMap<String, List<String>> redSocial = new HashMap<>();

redSocial.put("Ana", Arrays.asList("Bob", "Eva", "Fran", "Carlos", "Zelda"));
redSocial.put("Fran", Arrays.asList("Bob", "Ana", "Carlos"));
redSocial.put("Zelda", Arrays.asList("Carlos", "Ana", "Eva", "Mía"));
redSocial.put("Bob", Arrays.asList("Ana", "Fran"));
redSocial.put("Eva", Arrays.asList("Ana", "Zelda", "Luis"));
redSocial.put("Luis", Arrays.asList("Eva"));
redSocial.put("Carlos", Arrays.asList("Ana", "Fran", "Zelda"));
redSocial.put("Mía", Arrays.asList("Zelda"));