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

Antes de implementar listas o árboles a mano, necesitás 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 ser null 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 clase Nodo<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 el qué antes del cómo — coherente con el rol de ingeniero.

Contenido

📚 Elige un curso

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`)