1. El salto de «programador» a «ingeniero»

Antes de implementar listas o árboles a mano, necesitas el vocabulario de análisis de Java: tipos primitivos vs objetos, genéricos para reutilizar estructuras, y Big O para razonar sobre tiempo y memoria.

Tipos primitivos y wrappers (`int` vs `Integer`)

int, double, boolean… viven en la pila y no son objetos. Integer,Double, Boolean son clases envoltorio: encapsulan el valor y pueden sernull y usarse en colecciones genéricas que exigen referencias.

Primitivo vs wrapper

JAVA

int a = 5;
Integer b = Integer.valueOf(5); // preferible a new Integer(5)
Integer c = null;              // solo referencias permiten null
 
// Autoboxing / unboxing
Integer x = 10;   // boxing
int y = x;        // unboxing — cuidado si x fuera null (NPE)

En estructuras propias, si el nodo guarda un dato genérico, casi siempre modelarás el contenido como tipo referencia (T) o usarás wrappers cuando necesites null como «hueco».

Genéricos (`Generics`)

Sin genéricos, todo sería Object y perderías seguridad de tipos. Con <T>, una misma claseNodo<T> sirve para String, Persona, etc.

Nodo genérico (idea central del curso)

JAVA

public class Nodo<T> {
    private final T dato;
    private Nodo<T> siguiente;
 
    public Nodo(T dato) {
        this.dato = dato;
    }
    public T getDato() { return dato; }
    public Nodo<T> getSiguiente() { return siguiente; }
    public void setSiguiente(Nodo<T> siguiente) { this.siguiente = siguiente; }
}

Complejidad algorítmica (Big O)

Medís tiempo y espacio en función del tamaño de la entrada n. No hace falta contar milisegundos: comparás órdenes de crecimiento.

Notación	Nombre	Ejemplo típico
`O(1)`	Constante	Acceso por índice en arreglo, `peek` en pila
`O(log n)`	Logarítmica	Búsqueda en BST equilibrado, heap
`O(n)`	Lineal	Recorrer lista enlazada, un solo bucle sobre `n`
`O(n log n)`	Casi lineal	Merge sort, quick sort promedio
`O(n²)`	Cuadrática	Bucles anidados sobre el mismo `n` (p. ej. burbuja ingenua)

Propuesta de práctica: para cada método que escribas (insertar, buscar), anotá en un comentario // tiempo: O(?), espacio: O(?) y justificá con un argumento corto.

Interfaces como contrato

Antes de codificar, definí qué operaciones expone tu estructura: void insertar(T x),T eliminar(), boolean contiene(T x), etc. Las interfaces en Java te obligan a pensar elqué antes del cómo — coherente con el rol de ingeniero.

Contenido

📚 Cursos de Café y Código

1. El salto de «programador» a «ingeniero»

Tipos primitivos y wrappers (`int` vs `Integer`)

Genéricos (`Generics`)

Complejidad algorítmica (Big O)

Interfaces como contrato

¡Hecho con mucho cariño! ☕

1. El salto de «programador» a «ingeniero»

Tipos primitivos y wrappers (int vs Integer)

Genéricos (Generics)

Complejidad algorítmica (Big O)

Interfaces como contrato

Tipos primitivos y wrappers (`int` vs `Integer`)

Genéricos (`Generics`)