2. Estructuras lineales (hechas por vos)

El objetivo es no depender solo de ArrayList o LinkedList del JDK: programar vos mismo para ver cómo se enlazan los nodos en memoria.

Referencia = «puntero» en Java

nodo.siguiente = nuevoNodo; no copia un objeto entero: asigna una referencia. Dos variables pueden apuntar al mismo objeto; si mutás por una, la otra «ve» el cambio.

cabecera
   │
   ▼
┌──────┐    ┌──────┐    ┌──────┐
│  3   │───▶│  7   │───▶│  1   │───▶ null
└──────┘    └──────┘    └──────┘

Arreglos estáticos y dinámicos

Un T[] tiene tamaño fijo al crearlo. Un arreglo dinámico (como el corazón de ArrayList) mantiene capacidad y, al llenarse, copia a otro bloque más grande (coste amortizado O(1) por inserción al final).

Idea de crecimiento (esquema)

JAVA

  // Pseudocódigo conceptual 
  void add(T x) { 
      if (size == capacity) { 
          capacity *= 2; 
          elementos = Arrays.copyOf(elementos, capacity); 
      } 
      elementos[size++] = x; 
  } 

Lista enlazada: clase `Nodo`

Lista simplemente enlazada (enteros)

JAVA

  public class Nodo { 
      int valor; 
      Nodo siguiente; 
    
      public Nodo(int valor) { 
          this.valor = valor; 
      } 
  } 
    
  public class ListaEnlazada { 
      private Nodo cabeza; 
    
      public void agregarAlFinal(int v) { 
          Nodo n = new Nodo(v); 
          if (cabeza == null) { 
              cabeza = n; 
              return; 
          } 
          Nodo cur = cabeza; 
          while (cur.siguiente != null) { 
              cur = cur.siguiente; 
          } 
          cur.siguiente = n; 
      } 
  } 

Diseño visual: dibujá en papel la cabeza y cada flecha antes de depurar; cuando el depurador muestre cabeza → Nodo@1a2b, es exactamente ese grafo de referencias.

Pila (`Stack`) y cola (`Queue`)

PILA (LIFO)          push 5    push 2    pop → 2
        ┌───┐     ┌───┐     ┌───┐
        │   │     │ 5 │     │ 5 │
        └───┘     └───┘     └───┘

Pila: LIFO — último en entrar, primero en salir. Cola: FIFO. Podés implementarlas con nodos y punteros a cabeza/cola; documentá qué pasa en estructura vacía (EmptyStackException, NoSuchElementException o valores opcionales).

Interfaz mínima (contrato)

JAVA

  public interface Pila<T> { 
      void push(T item); 
      T pop(); 
      T peek(); 
      boolean isEmpty(); 
  } 

Contenido

📚 Elige un curso

2. Estructuras lineales (hechas por vos)

Referencia = «puntero» en Java

Arreglos estáticos y dinámicos

Lista enlazada: clase `Nodo`

Pila (`Stack`) y cola (`Queue`)

¡Hecho con mucho cariño! ☕

2. Estructuras lineales (hechas por vos)

Referencia = «puntero» en Java

Arreglos estáticos y dinámicos

Lista enlazada: clase Nodo

Pila (Stack) y cola (Queue)

Lista enlazada: clase `Nodo`

Pila (`Stack`) y cola (`Queue`)