Operaciones básicas con arrays unidimensionales

1. Introducción

¿Qué solemos querer hacer con los arrays?

Vamos a enumerar las operaciones básicas:

• Leer y modificar elementos del array por índice.
• Buscar un elemento por valor.
• Copiar un array, crear “trozos” (parte del array).
• Ordenar el array.
• Invertir (dar la vuelta) el array.
• Rellenar el array con un valor.
• Comprobar si existe un elemento (si el array contiene un valor dado).
• Cambiar la longitud (resize).

En problemas reales te vas a encontrar con estas acciones muy a menudo — por ejemplo, “¿hay alguna suma mayor que 4000?”, “encuentra el primer precio menor que 1000”, “ordena los precios de menor a mayor”, etc.

Y para todo esto tenemos funciones

arr[n] = x

Array.IndexOf(arr, v)

Array.Exists(arr, pred)

Array.Sort(arr)

Array.Reverse(arr)

arr.Clone(), Array.Copy

Array.Fill(arr, val)

Array.Resize(ref arr, len)

arr.Max(), arr.Min()

2. Leer y modificar elementos por índice

Esto ya lo hemos visto, pero vamos a repasarlo con un ejemplo sencillo (supongamos que tenemos un array de notas):

// Array de notas del estudiante
int[] grades = { 4, 3, 5, 2, 5 };

// Leer la primera nota
int firstGrade = grades[0];
Console.WriteLine($"Primera nota: {firstGrade}");

// Cambiar la última nota a "sobresaliente" (5)
grades[^1] = 5;
Console.WriteLine("Última nota modificada: " + grades[^1]);

Lo importante aquí: los índices empiezan en cero, y si intentas acceder a un índice que no existe te sale el error IndexOutOfRangeException — un clásico en entrevistas y en la vida real.

3. Buscar un elemento en el array

Tenemos dos funciones que buscan un elemento en el array y devuelven su índice si lo encuentran.

Función Array.IndexOf(value [, from])

La función Array.IndexOf busca el elemento dado desde el principio del array. Si lo encuentra, devuelve su índice. Si no — devuelve -1.

¿Pero qué pasa si quieres encontrar las siguientes apariciones de ese elemento en el array? Para eso, a la función Array.IndexOf le puedes pasar un segundo parámetro — el índice desde el que empieza a buscar. Ese debe ser el índice del último elemento encontrado + 1.

Vamos a buscar todas las apariciones del número 2 en nuestro array:

int[] grades = { 4, 3, 5, 2, 5, 2 };
int x = 2; // elemento que buscamos

int index = Array.IndexOf(grades, x);
while (index != -1)
{
    Console.WriteLine($"Elemento {x} encontrado en la posición: {index}");
    // Buscamos el siguiente índice, empezando desde index + 1
    index = Array.IndexOf(grades, x, index + 1);
} 

Función Array.LastIndexOf(value [, from])

La función Array.LastIndexOf busca el elemento dado desde el final del array. Si lo encuentra, devuelve su índice. Si no — devuelve -1. Por lo demás es igual que Array.IndexOf.

Vamos a buscar todas las apariciones del número 2 en nuestro array, pero buscando desde el final:

int[] grades = { 4, 3, 5, 2, 5, 2 };
int x = 2; // elemento que buscamos

int index = Array.LastIndexOf(grades, x);
while (index != -1)
{
    Console.WriteLine($"Elemento {x} encontrado en la posición: {index}");
    // Buscamos el siguiente índice, empezando desde la posición anterior - 1
    index = Array.LastIndexOf(grades, x, index - 1);
}

4. Comprobar si existe un elemento en el array

Para comprobar si existe un elemento tienes la función Contains. Este método devuelve true si el array contiene el elemento indicado. Para que funcione tienes que importar el módulo System.Linq. Ejemplo:

using System.Linq; // Añade using System.Linq; si no lo tienes

bool hasExcellent = grades.Contains(5); 
Console.WriteLine($"¿Hay un cinco? {hasExcellent}");

Muy fácil y elegante.

5. Invertir un array: Array.Reverse

Supón que quieres darle la vuelta al array. Usa esto:

int[] grades = { 2, 3, 4, 5 };

// Invertimos el array
Array.Reverse(grades);
Console.WriteLine("Notas invertidas: " + string.Join(", ", grades));

Esto es muy útil para buscar los datos “más recientes” o simplemente si te mola ver el mundo al revés.

6. Ordenar un array: Array.Sort

Tarde o temprano vas a querer ordenar un array. El camino más corto y seguro es usar la función estándar de ordenación:

int[] grades = { 4, 3, 5, 2, 5 };
// Ordenamos de menor a mayor
Array.Sort(grades);
Console.WriteLine("Notas ordenadas: " + string.Join(", ", grades));

Esta función también ordena strings, pero en orden alfabético.

Ordenar de mayor a menor

El Array.Sort estándar solo ordena de menor a mayor. Para ordenar de mayor a menor puedes usar sort + reverse:

Array.Sort(grades); // Primero de menor a mayor
Array.Reverse(grades); // Luego le damos la vuelta
Console.WriteLine("De mayor a menor: " + string.Join(", ", grades));

Nota: mucha gente olvida que la ordenación es “in place”: el array se modifica, no se devuelve uno nuevo. Si necesitas el orden original, primero haz una copia del array original.

7. Clonar un array: Clone y Array.Copy

Si necesitas hacer una copia (y no quieres romper el array original al procesarlo), usa los métodos Clone() y Array.Copy().

El método Clone() se llama sobre el array y te devuelve una copia completa.

El método Array.Copy() necesita que le pases los datos:

• el array origen;
• el array destino;
• cuántas celdas copiar.

int[] original = { 1, 2, 3, 4, 5 };

// Forma 1: Clone()
// Funciona para arrays uni y multidimensionales, pero devuelve object, necesitas type cast:
int[] copy1 = (int[]) original.Clone();

// Forma 2: Array.Copy
int[] copy2 = new int[original.Length];
Array.Copy(original, copy2, original.Length);

Detalle importante: los arrays se copian por valor si son tipos primitivos (int, double). Si es un array de objetos, ¡solo se copian las referencias! (lo que se llama “copia superficial”).

8. Rellenar un array con un valor: Array.Fill

¿Quieres “poner a cero” un array o llenarlo todo de cincos? Para eso tienes el método Array.Fill:

int[] grades = new int[5];
Array.Fill(grades, 5); // Ahora todos los elementos son 5
Console.WriteLine("Estudiante hipotéticamente perfecto: " + string.Join(", ", grades));

Útil cuando necesitas inicializar rápidamente un array con un valor concreto.

9. Buscar el valor máximo y mínimo

El módulo System.Linq añadió muchos métodos útiles a los arrays, y dos de ellos devuelven el valor mínimo y máximo del array. Se llaman Max() y Min().

Vamos a encontrar la nota máxima y mínima en el array:

int maxGrade = grades.Max();
int minGrade = grades.Min();
Console.WriteLine($"Nota máxima: {maxGrade}, mínima: {minGrade}");

No olvides añadir using System.Linq; para estos métodos.

2

Tarea

C# SELF, nivel 7, lección 3

Bloqueada

Ordenar un array y encontrar el elemento máximo

Ordenar un array y encontrar el elemento máximo

Abrir

2

Tarea

C# SELF, nivel 7, lección 3

Bloqueada

Buscar todas las apariciones de un elemento en un array

Buscar todas las apariciones de un elemento en un array

Abrir