Operaciones avanzadas de arrays
En este paso, exploraremos algunas operaciones avanzadas que se pueden realizar en arrays, como encontrar los valores máximo y mínimo, y ordenar el array. Estas técnicas son esenciales para el análisis de datos, el procesamiento y la implementación de algoritmos.
Escribamos un programa para encontrar los valores máximo y mínimo en un array:
cd ~/project
touch find_max_min.c
#include <stdio.h>
int main() {
int numbers[5] = {10, 20, 30, 40, 50};
int max = numbers[0];
int min = numbers[0];
for (int i = 1; i < 5; i++) {
if (numbers[i] > max) {
max = numbers[i];
}
if (numbers[i] < min) {
min = numbers[i];
}
}
printf("Maximum value: %d\n", max);
printf("Minimum value: %d\n", min);
return 0;
}
Este código demuestra una técnica simple pero poderosa para encontrar los valores máximo y mínimo en un array. Al inicializar max y min con el primer elemento y luego comparar cada elemento subsiguiente, podemos identificar eficientemente los valores extremos en el array.
Líneas clave de código:
- Inicialización:
int max = numbers[0]; int min = numbers[0]; - Las variables max y min se inicializan con el primer elemento del array. Este paso proporciona un punto de partida para la comparación.
- Bucle de comparación:
for (int i = 1; i < 5; i++) - Este bucle for comienza desde el índice 1 (el segundo elemento) hasta el final del array. Esto asegura que cada valor subsiguiente se verifique en comparación con los valores max y min existentes.
- Encontrar el máximo:
if (numbers[i] > max) { max = numbers[i]; } - Este bloque comprueba si el elemento actual es mayor que el max actual. Si es verdadero, la variable max se actualiza al valor del elemento actual.
- Encontrar el mínimo:
if (numbers[i] < min) { min = numbers[i]; } - De manera similar, esto comprueba si el elemento actual es menor que el min actual, actualizando min cuando se encuentra un valor más pequeño.
A continuación, escribamos un programa para ordenar el array en orden ascendente utilizando el algoritmo de ordenamiento de burbuja (bubble sort):
cd ~/project
touch bubble_sort.c
#include <stdio.h>
void bubbleSort(int arr[], int n) {
for (int i = 0; i < n-1; i++) {
for (int j = 0; j < n-i-1; j++) {
if (arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
int main() {
int numbers[5] = {50, 20, 30, 10, 40};
bubbleSort(numbers, 5);
printf("Sorted array:\n");
for (int i = 0; i < 5; i++) {
printf("numbers[%d] = %d\n", i, numbers[i]);
}
return 0;
}
El ordenamiento de burbuja es un algoritmo de ordenamiento clásico que recorre repetidamente la lista, compara elementos adyacentes y los intercambia si están en el orden incorrecto. Aunque no es el método de ordenamiento más eficiente para conjuntos de datos grandes, proporciona una excelente introducción a los conceptos de ordenamiento y la manipulación de arrays.
Líneas clave de código:
- Bucle exterior:
for (int i = 0; i < n-1; i++) - Este bucle exterior controla el número de pasadas a través del array. El bucle se ejecuta hasta n - 1 veces (donde n es el tamaño del array) porque el elemento más grande estará en su posición final después de cada pasada.
- Bucle interior:
for (int j = 0; j < n-i-1; j++) - El bucle interior realiza las comparaciones y intercambios reales. A medida que los elementos más grandes "flotan" hacia el final, el rango del bucle interior se reduce, por eso tenemos n - i - 1 en lugar de n.
- Comparación:
if (arr[j] > arr[j+1]) - Esta declaración comprueba si el elemento actual es mayor que el siguiente elemento.
- Intercambio: Las líneas
int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; realizan el intercambio de los dos elementos, cuando arr[j] es mayor que arr[j+1]. Se utiliza una variable temporal temp para evitar perder uno de los valores durante el intercambio.
Para compilar y ejecutar los programas, utiliza los siguientes comandos en la terminal:
gcc find_max_min.c -o find_max_min
./find_max_min
gcc bubble_sort.c -o bubble_sort
./bubble_sort
Ejemplo de salida para encontrar el máximo y el mínimo:
Maximum value: 50
Minimum value: 10
Ejemplo de salida para el ordenamiento:
Sorted array:
numbers[0] = 10
numbers[1] = 20
numbers[2] = 30
numbers[3] = 40
numbers[4] = 50
Estos ejemplos ilustran operaciones fundamentales de arrays que forman los bloques de construcción de técnicas de procesamiento de datos más complejas en la programación en C.
