Ordenar Array Dinámico con C++
Este pequeño programa de 74 líneas de código ordena un Array Dinámico de mayor a menor o de menor a mayor según la opción que elija el usuario. Un array dinámico básicamente es un contenedor de elementos no ordenados de un solo tipo y de tamaño flexible, puede expandirse en tiempo de ejecución cuando se agregan elementos.
#include <iostream>
using namespace std;
void mayor(int valores[], int cant){
int aux;
for(int i = 0; i < cant; i++){
for(int x = 0; x < cant; x++){
if(valores[i] > valores[x]){
aux = valores[i];
valores[i] = valores[x];
valores[x] = aux;
}
}
}
cout << "\nArray dinamico ordenado: ";
for(int i = 0; i < cant; i++){
cout << "{" << valores[i] << "} ";
}
cout << "Fin!" << endl;
}
void menor(int valores[], int cant){
int aux;
for(int i = 0; i < cant; i++){
for(int x = 0; x < cant; x++){
if(valores[i] < valores[x]){
aux = valores[x];
valores[x] = valores[i];
valores[i] = aux;
}
}
}
cout << "\nArray dinamico ordenado: ";
for(int i = 0; i < cant; i++){
cout << "{" << valores[i] << "} ";
}
cout << "Fin!" << endl;
}
int main() {
int *valores, cant, num, resp;
cout << "Cuantos valores desea ingresar?: ";
cin >> cant;
valores = new int[cant];
for(int i = 0; i < cant; i++){
cout << "Ingrese el valor No. " << i << ": ";
cin >> num;
valores[i] = num;
}
cout << "\nSelecciones una de las siguientes opciones" << endl;
cout << "------------------------------------------" << endl;
cout << "1) Ordenar de mayor a menor" << endl;
cout << "2) Ordenar de menor a mayor" << endl;
cout << "------------------------------------------" << endl;
cout << "Opcion: ";
cin >> resp;
switch(resp) {
case 1:
mayor(valores, cant);
break;
case 2:
menor(valores, cant);
break;
default:
cout << "Opcion invalida!" << endl;
}
return 0;
}
Aquí hay varios temas básicos que como lo son, objetos cout y cin, función main, sentencia return, cabeceras y espacios de nombres que se explican en Hola Mundo. Por lo tanto no se explicaran en esta publicación.
iostream y using namespace
#include <iostream> using namespace std;
Incluimos la cabecera iostream, ella nos permite realizar operaciones de entrada y salida de datos usando los objetos cout y cin. En la segunda línea incorporamos el espacio de nombres std, esto nos permitirá usar los objetos mencionados anteriormente y otros objetos sin el prefijo std::; por ejemplo, std::cout.
Función mayor()
void mayor(int valores[], int cant){
int aux;
for(int i = 0; i < cant; i++){
for(int x = 0; x < cant; x++){
if(valores[i] > valores[x]){
aux = valores[i];
valores[i] = valores[x];
valores[x] = aux;
}
}
}
cout << "\nArray dinamico ordenado: ";
for(int i = 0; i < cant; i++){
cout << "{" << valores[i] << "} ";
}
cout << "Fin!" << endl;
}
La función mayor() ordena los elementos de un Array Dinámico de mayor a menor. Recibe dos argumentos, el primero es un array de tipo int y el segundo es la cantidad de elementos del array, que también es de tipo int.
Variable aux
Esta variable será solo una auxiliar durante el proceso para ordenar los elementos del array, sosteniendo los valores individuales para luego devolverlos al mismo array pero en una posición diferente.
Bucle for() con un bucle for() anidado
for(int i = 0; i < cant; i++){
for(int x = 0; x < cant; x++){
if(valores[i] > valores[x]){
aux = valores[i];
valores[i] = valores[x];
valores[x] = aux;
}
}
}
Ambos bucles van a iterar desde 0 hasta N – 1, con la diferencia que el bucle externo va a iterar solo una vez por cada elemento del array en la posición i; mientras que el bucle interno va a iterar desde 0 hasta N – 1 por cada elemento en la posición i; por ejemplo, si hay 5 elemento en el array, el bucle interno va a iterar 5 veces por cada elemento elemento en el índice i, para un total de 25 iteraciones.
Sentencia if(), ordenando Array Dinámico
if(valores[i] > valores[x]){
aux = valores[i];
valores[i] = valores[x];
valores[x] = aux;
}
La sentencia if() va a evaluar si cada uno de los elementos del array ubicado en el índice i es mayor a los elementos del array ubicado en el índice x, por eso el bucle interno va a iterar N cantidad de veces por cada elemento en el índice i (como se explicó anteriormente) con la intención de evaluar si es mayor al elemento en el índice x. Si la condición es true, se realizan una serie de asignaciones que se explican a continuación:
* aux = listNum[i]: el elemento en el índice i es asignado a la variable aux.
* listNum[i] = listNum[x]: el elemento ubicado en el índice x es asignado asignado en el índice i.
* listNum[x] = aux: el elemento que había sido asignado a la variable aux es asignado en el índice x.
Este pequeño proceso cambia de posición a los elementos, moviendo de índices a cada uno, para dejar a los números mayores al principio del array y dejado de últimas a los números menores.
Mostrando array ordenado con el bucle for()
cout << "\nArray dinamico ordenado: ";
for(int i = 0; i < cant; i++){
cout << "{" << valores[i] << "} ";
}
cout << "Fin!" << endl;
Este bucle es el más sencillo de todo el proceso, ya que solo va a iterar desde 0 mientras que la variable i sea menor a cant (igual que los bucles anteriores), en donde cant es la cantidad de valores que hay en el array dinámico. El objeto cout en la línea #3 imprime los elementos del array uno por uno accediendo a ellos según su índice i, usando la expresión valores[i]. Las llaves entre comillas “{“ y “}” se usan como algo estético para que cada número se imprima de la siguiente forma: {10} {8} {5}.
El objeto cout en la última línea no hace más que imprimir la palabra “Fin” y da un salto de línea usando endl.
Función menor()
void menor(int valores[], int cant){
int aux;
for(int i = 0; i < cant; i++){
for(int x = 0; x < cant; x++){
if(valores[i] < valores[x]){
aux = valores[x];
valores[x] = valores[i];
valores[i] = aux;
}
}
}
cout << "\nArray dinamico ordenado: ";
for(int i = 0; i < cant; i++){
cout << "{" << valores[i] << "} ";
}
cout << "Fin!" << endl;
}
Esta función tiene exactamente la misma estructura que la función mayor() y de hecho funciona de la misma forma, solo hay un par de diferencias entre ambas que se encuentra en la sentencia if():
* La sentencia if() de la función mayor() evalúa si los elementos ubicados en el índice i son mayores que los elementos ubicados en el índice x; mientras que en la función menor() se evalúa si los elementos en el índice i son menores que los elementos en el índice x.
* En la función mayor() la variable aux toma el valor que hay en el índice i del array; mientra que en la función menor() la variable aux toma el valor que hay en el índice x.
* En la función mayor() el índice i del array toma el valor del índice x del array; mientras que en la función menor() el índice x toma el valor del índice i.
* En la función mayor() el índice x del array toma el valor de la variable aux; mientras que en la función menor() el índice i toma el valor de la variable aux.
Función main()
int main() {
int *valores, cant, num, resp;
cout << "Cuantos valores desea ingresar?: ";
cin >> cant;
valores = new int[cant];
for(int i = 0; i < cant; i++){
cout << "Ingrese el valor No. " << i << ": ";
cin >> num;
valores[i] = num;
}
cout << "\nSelecciones una de las siguientes opciones" << endl;
cout << "------------------------------------------" << endl;
cout << "1) Ordenar de mayor a menor" << endl;
cout << "2) Ordenar de menor a mayor" << endl;
cout << "------------------------------------------" << endl;
cout << "Opcion: ";
cin >> resp;
switch(resp) {
case 1:
mayor(valores, cant);
break;
case 2:
menor(valores, cant);
break;
default:
cout << "Opcion invalida!" << endl;
}
return 0;
}
La función main() es obligatoria en C++, es la única función que es llamada cuando se ejecuta el programa y todo lo que se encuentro dentro de ella será ejecutado. Esta función puede llevar o no parámetros.
Creando variables
int *valores, cant, num, resp;
Se crean 4 variables de tipo int, pero solo la primera es un puntero a int ya que ella se convertirá en el array dinámico más adelante; las demás variables serán usadas para recibir y procesar valores ingresados por el usuario, la variable cant recibe la cantidad de elementos que tendrá el array, la variable resp recibe solo 2 valores y la variable num recibe cada uno de los valores que tendrá el array.
Solicitando y leyendo cantidad de valores del array
cout << "¿Cuantos valores desea ingresar?: "; cin >> cant;
El objeto cout imprime un mensaje preguntando al usuario cuantos valores desea ingresar; por ejemplo, 10 y con el objeto cin leemos el valor ingresado por el usuario y lo almacenamos en la variable cant.
Creando Array Dinámico, operador new[]
valores = new int[cant];
Para crear un array dinámico en C++ debemos usar el operador new[] y entre corchetes debe ir el tamaño que deseamos que tenga el array, esto asigna memoria en tiempo de ejecución, permitiendo que se puedan crear arrays de cualquier tamaño (siempre y cuando la memoria RAM alcance) en tiempo de ejecución.
Bucle for(), agregando elementos al array
for(int i = 0; i < cant; i++){
cout << "Ingrese el valor No. " << i + 1 << ": ";
cin >> num;
valores[i] = num;
}
El bucle for() va a iterar la cantidad de veces indicadas por el usuario en la variable cant, pero iniciando desde 0; por ejemplo, desde 0 hasta 4 si la variable cant vale 5. El objeto cout solo imprime un mensaje informando al usuario que ingrese un valor junto con el número de valores que se van ingresando sumando a i + 1. Con el objeto cin leemos cada valor ingresado por el usuario y lo almacenamos en la variable num; por último se agregar cada valor al array como se muestra en la línea #4, indicando el índice en donde será agregado.
Seleccionando una opción y mostrando el resultado
cout << "\nSelecciones una de las siguientes opciones" << endl;
cout << "------------------------------------------" << endl;
cout << "1) Ordenar de mayor a menor" << endl;
cout << "2) Ordenar de menor a mayor" << endl;
cout << "------------------------------------------" << endl;
cout << "Opcion: ";
cin >> resp;
switch(resp) {
case 1:
mayor(valores, cant);
break;
case 2:
menor(valores, cant);
break;
default:
cout << "Opcion invalida!" << endl;
}
Los 5 primeros objetos cout muestran en la terminal un menú de la siguiente forma:
Selecciones una de las siguientes opciones ------------------------------------------ 1) Ordenar de mayor a menor 2) Ordenar de menor a mayor ------------------------------------------
Es un menú que le indica al usuario seleccionar alguna de las dos opciones presentes, ingresar el número 1 si desea ordenar el array de mayor a menor o el número 2 si lo desea ordenar de menor a mayor. El objeto cout en la línea #6 solo muestra la palabra “Opcion: ” y con el objeto cin leemos la opción elegida por el usuario y lo almacenamos en la variable resp.
La sentencia switch() toma la variable resp y evalúa la opción que el usuario escogió y dependiendo de esto entonces llama a la función mayor() o menor() que recibe 2 parametros, el primero es el array dinámico y el segundo es la cantidad de elementos que posee dicho array.
Liberando memoria
delete[] valores;
En C++ no hay un recolector de basura que libere memoria de forma automatica, asi que toca hacerlo de forma manual. Liberamos la memoria asignada al array dinámico usando el operador delete[].
Compilando y ejecutando el programa
Al compilar y ejecutar este pequeño programa nos da un resultado similar al siguiente:
[fixedtorres@linuxero]$ g++ -std=c++14 OrdenarArrayDinamico.cpp -o OrdenarArrayDinamico
[fixedtorres@linuxero]$ ./OrdenarArrayDinamico
¿Cuantos valores desea ingresar?: 5
Ingrese el valor No. 1: 2007
Ingrese el valor No. 2: 1801
Ingrese el valor No. 3: 1991
Ingrese el valor No. 4: 2017
Ingrese el valor No. 5: 1998
Selecciones una de las siguientes opciones
------------------------------------------
1) Ordenar de mayor a menor
2) Ordenar de menor a mayor
------------------------------------------
Opcion: 2
Array dinamico ordenado: {1801} {1991} {1998} {2007} {2017} Fin!
[fixedtorres@linuxero]$
Un array ordenado de menor a mayor si seleccionamos la opción #2.
