Eliminar

Eliminando elementos con eliminarEn

[🟩 🟩 🟩 🟩]   contador = 4

Este método recibe un índice y elimina el elemento correspondiente del arreglo.

Eliminando elementos con eliminarEn

[🟩 🟩 🟩 🟩]   contador = 4

Primero debemos validar el índice y luego mover los elementos restantes a la izquierda para llenar el hueco.

Validando el índice

Si alguien pasa un índice inválido, como -1 o 5, eso no tiene sentido.

❌ índice -1 → error  
❌ índice 5  → error  
🟩 índice 0–3 → válido

Validando el índice

El último índice válido es contador - 1.

❌ índice -1 → error  
❌ índice 5  → error  
🟩 índice 0–3 → válido

Validando el índice

Por eso, si el índice está fuera de rango, lanzamos una excepción para detener el programa.

❌ índice -1 → error  
❌ índice 5  → error  
🟩 índice 0–3 → válido

Eliminando un elemento en el índice 1

[10, 20, 30, 40]

Supongamos que el arreglo contiene los valores:

Eliminando un elemento en el índice 1

[10, ❌20, 30, 40]

Queremos eliminar el elemento con índice 1, es decir, el 20. Marcamos el elemento que desaparecerá:

Desplazando los elementos a la izquierda

[10, 30, 40, ⬜]

Después de eliminar, los elementos de la derecha se mueven una posición hacia la izquierda.

Desplazando los elementos a la izquierda

[10, 30, 40]

Así se “rellena” el hueco.

Arreglo actualizado

[🟩 🟩 🟩 🟩]    contador = 3

El resultado final es este:

Arreglo actualizado

[🟩 🟩 🟩 ⬜]

El arreglo sigue ordenado, sin huecos, y preparado para nuevas inserciones ✅

Implementación en Java

public void eliminarEn(int index) {

    // 1️⃣ Validar el índice
   
}

Implementación en Java

public void eliminarEn(int index) {

    // 1️⃣ Validar el índice
     if (index < 0 || index >= contador) // 4
            throw new IllegalArgumentException();
   
}

Paso a paso

Arreglo inicial y objetivo:

[10, 20, 30, 40]  →  eliminar índice 1

Iteración i = 1 items[1] = items[2] → [10, 30, 30, 40]

Iteración i = 2 items[2] = items[3] → [10, 30, 40, 40]

Fin del bucle → contador-- → [10, 30, 40, ⬜]

Código esencial del corrimiento

El bucle va hasta el penúltimo (contador - 1) para no salirse con i + 1.

// 2️⃣ Desplazar los elementos a la izquierda
     for (int i = index; i < contador; i++)
            items[i] = items[i + 1];

        contador--;

Implementación en Java

public void eliminarEn(int index) {

        if (index < 0 || index >= contador)
            throw new IllegalArgumentException();

        for (int i = index; i < contador; i++)
            items[i] = items[i + 1];

        contador--;
    }

Probemos nuestro método

public class Main {
    public static void main(String[] args) {
        Arreglo numeros = new Arreglo(3);
        numeros.insertar(10);
        numeros.insertar(20);
        numeros.insertar(30);
        numeros.insertar(50);
        System.out.println("antes");
        numeros.imprimir();
        numeros.eliminarEn(1);
        System.out.println("después");
        numeros.imprimir();

    }
}

Resultado esperado en consola:

antes
10
20
30
50

Resultado esperado en consola:

después
10
30
50

Clase Arreglo

public class Arreglo {

    private int[] items;

    // Nuevo campo: número de elementos realmente insertados
    private int contador;

    public Arreglo(int longitud){
        items = new int[longitud];
        contador = 0; // al inicio, el arreglo está vacío
    }


    public void insertar(int item) {
         if (items.length == contador) {
            int[] newItems = new int[contador * 2];

            for (int i = 0; i < contador; i++)
                newItems[i] = items[i];

            items = newItems;
        }

         items[contador++] = item;


    }



    public void eliminarEn(int index) {

        if (index < 0 || index >= contador)
            throw new IllegalArgumentException();

        for (int i = index; i < contador; i++)
            items[i] = items[i + 1];

        contador--;
    }


    public void imprimir() {
        for (int i = 0; i < contador; i++)
            System.out.println(items[i]);
    }

}