Ordenar Array Dinámico con Go

Este pequeño programa de apenas 69 líneas de código nos permite ordenar un array dinámico de mayor a menor o de menor a mayor, según la opción seleccionada por el usuario. Un array dinámico es un contenedor de elementos no ordenados de un solo tipo y de tamaño flexible, que se expande en tiempo de ejecución cuando se agregan elementos.

Código fuente
package main

import "fmt"

func ordenarMayor(listNum []int, Cant int) {
    tmp := 0
    for x := 0; x < Cant; x++ {
        for y := 0; y < Cant; y++ {
            if listNum[x] > listNum[y] {
                tmp = listNum[x]
                listNum[x] = listNum[y]
                listNum[y] = tmp
            }
        }
    }
    fmt.Print("\nArray dinamico ordenado: ")
    for i := 0; i < Cant; i++ {
        fmt.Print("[",listNum[i],"]")
    }
    fmt.Println()
}

func ordenarMenor(listNum []int, Cant int) {
    tmp := 0
    for x := 0; x < Cant; x++ {
        for y := 0; y < Cant; y++ {
            if listNum[x] < listNum[y] {
                tmp = listNum[y]
                listNum[y] = listNum[x]
                listNum[x] = tmp
            }
        }
    }
    fmt.Print("\nArray dinamico ordenado: ")
    for i := 0; i < Cant; i++ {
        fmt.Print("[",listNum[i],"]")
    }
    fmt.Println()
}

func main() {
    listNum := make([]int, 0)
    var cant, opt, valor int

    fmt.Print("¿Cuantos valores desea ingresar?: ")
    fmt.Scanf("%d", &cant)
    for v := 1; v <= cant; v++ {
        fmt.Print("Ingrese en valor #", v, ": ")
        fmt.Scanf("%d", &valor)
        listNum = append(listNum, valor)
    }

    fmt.Println("\nSelecciones una de las siguientes opciones")
    fmt.Println("------------------------------------------")
    fmt.Println("1) Ordenar de mayor a menor")
    fmt.Println("2) Ordenar de menor a mayor")
    fmt.Println("------------------------------------------")
    fmt.Print("Opcion: ")
    fmt.Scanf("%d", &opt)

    switch opt {
    case 1:
        ordenarMayor(listNum, cant)
    case 2:
        ordenarMenor(listNum, cant)
    default:
        fmt.Println("Opcion no valida!!")
    }
}

Antes de iniciar es bueno recordar que la sentencia package es obligatoria en todo archivo fuente de Go, junto a ella va el nombre del paquete, pero solo el archivo principal del ejecutable debe llamarse main.



Importando paquetes
import "fmt"

Importamos el paquete «fmt», él nos permitirá realizar operaciones de lectura de datos ingresados por el usuario y mostrarlos en pantalla. El nombre del paquete debe ir entre comillas.

Función ordenarMayor()
func ordenarMayor(listNum []int, Cant int) {
    tmp := 0
    for x := 0; x < Cant; x++ {
        for y := 0; y < Cant; y++ {
            if listNum[x] > listNum[y] {
                tmp = listNum[x]
                listNum[x] = listNum[y]
                listNum[y] = tmp
            }
        }
    }
    fmt.Print("\nArray dinamico ordenado: ")
    for i := 0; i < Cant; i++ {
        fmt.Print("[",listNum[i],"]")
    }
    fmt.Println()
}

La función ordenarMayor() es la encargada de tomar el array y ordenar sus elementos 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 tmp

Esta variable solo juega el papel de auxiliar en 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 x := 0; x < Cant; x++ {
    for y := 0; y < Cant; y++ {
        if listNum[x] > listNum[y] {
            tmp = listNum[x]
            listNum[x] = listNum[y]
            listNum[y] = tmp
        }
    }
}

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 x; mientras que el bucle interno va a iterar desde 0 hasta N – 1 por cada elemento en la posición x; por ejemplo, si hay 5 elemento en el array, el bucle interno va a iterar 5 veces por cada elemento elemento en el índice x, para un total de 25 iteraciones.

Sentencia if, evaluando y ordenando array
if listNum[x] > listNum[y] {
    tmp = listNum[x]
    listNum[x] = listNum[y]
    listNum[y] = tmp
}

Esta sentencia if va a evaluar si cada uno de los elementos del array ubicado en el índice x es mayor a los elementos del array ubicado en el índice y, por eso el bucle interno va a iterar N cantidad de veces por cada elemento en el índice x (como se explicó anteriormente) con la intención de evaluar si es mayor al elemento en el índice y. Si la condición es true, se realizan una serie de asignaciones que se explican a continuación:

tmp = listNum[x]: el elemento en el índice x es asignado a la variable tmp.

* listNum[x] = listNum[y]: el elemento ubicado en el índice y es asignado asignado en el índice x.

* listNum[y] = tmp: el elemento que había sido asignado a la variable tmp es asignado en el índice y.

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.

Bucle for, mostrando el array ordenado
fmt.Print("\nArray dinamico ordenado: ")
for i := 0; i < Cant; i++ {
    fmt.Print("[",listNum[i],"]")
}
fmt.Println()

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. La función Println() 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 listNum[i]; los corchetes entre comillas «[« y «]» se usan como algo estético para que cada número se imprima de la siguiente forma: [10] [4] [3].

La última función Println() solo genera un salto de línea al final del proceso.

Función ordenarMenor()
func ordenarMenor(listNum []int, Cant int) {
    tmp := 0
    for x := 0; x < Cant; x++ {
        for y := 0; y < Cant; y++ {
            if listNum[x] < listNum[y] {
                tmp = listNum[y]
                listNum[y] = listNum[x]
                listNum[x] = tmp
            }
        }
    }

    fmt.Print("\nArray dinamico ordenado: ")
    for i := 0; i < Cant; i++ {
        fmt.Print("[",listNum[i],"]")
    }
    fmt.Println()
}

Esta función tiene exactamente la misma estructura que la función ordenarMayor() 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 ordenarMayor() evalúa si los elementos ubicados en el índice x son mayores que los elementos ubicados en el índice y; mientras que en la función ordenarMenor() se evalúa si los elementos en el índice x son menores que los elementos en el índice y.

* En la función ordenarMayor() la variable tmp toma el valor que hay en el índice x del array; mientra que en la función ordenarMenor() la variable tmp toma el valor que hay en el índice y.

* En la función ordenarMayor() el índice x del array toma el valor del índice y del array; mientras que en la función ordenarMenor() el índice y toma el valor del índice x.

* En la función ordenarMayor() el índice y del array toma el valor de la variable tmp; mientras que en la función ordenarMenor() el índice x toma el valor de la variable tmp.


Función main()
func main() {
    listNum := make([]int, 0)
    var cant, opt, valor int

    fmt.Print("¿Cuantos valores desea ingresar?: ")
    fmt.Scanf("%d", &cant)
    for v := 1; v <= cant; v++ {
        fmt.Print("Ingrese el valor #", v, ": ")
        fmt.Scanf("%d", &valor)
        listNum = append(listNum, valor)
    }

    fmt.Println("\nSelecciones una de las siguientes opciones")
    fmt.Println("------------------------------------------")
    fmt.Println("1) Ordenar de mayor a menor")
    fmt.Println("2) Ordenar de menor a mayor")
    fmt.Println("------------------------------------------")
    fmt.Print("Opcion: ")
    fmt.Scanf("%d", &opt)

    switch opt {
    case 1:
        ordenarMayor(listNum, cant)
    case 2:
        ordenarMenor(listNum, cant)
    default:
        fmt.Println("Opcion no valida!!")
    }
}

La función main() es obligatoria en Go, 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 no lleva parámetros de ningún tipo.

Creando array dinámico
listNum := make([]int, 0)

La función make() recibe dos argumentos, el primer argumento es el tipo de array que deseamos «[]int» y el segundo argumento es la longitud del array. Con esto hemos creado un array dinámico que solo almacena elementos de tipo int con longitud 0 llamado listNum, no hay inconveniente con la longitud ya que el array tiene la propiedad de expandirse conforme vamos agregando elementos.

Creando variables
var cant, opt, valor int

Creamos 3 variables de tipo int que serán usadas más adelante para recibir y procesar valores ingresados por el usuario, la variable cant recibe la cantidad de elementos que tendrá el array, la variable opt recibe solo 2 valores y la variable valor recibe cada uno de los valores que tendrá el array.

Solicitando cantidad y leyendo el valor
fmt.Print("¿Cuantos valores desea ingresar?: ")
fmt.Scanf("%d", &cant)

Con la función fmt.Print() le preguntamos al usuario cuántos valores desea ingresar en el array; por ejemplo, 5. Con la función fmt.Scanf() leemos el valor que el usuario digita en la terminal, entre comillas se indica que tipo de valor se ingresa «%d», ya que vamos leer un valor decimal y separado por una coma pasamos por referencia la variable en la que se almacena con el signo «&».

Agregando elementos al array
for v := 1; v <= cant; v++ {
    fmt.Print("Ingrese el valor #", v, ": ")
    fmt.Scanf("%d", &valor)
    listNum = append(listNum, valor)
}

El bucle for va a iterar la cantidad de veces indicadas por el usuario en la variable cant, por ejemplo, desde 1 hasta 5. La función fmt.Print() imprime un mensaje indicando al usuario que ingrese el valor #x, por ejemplo, «Ingrese el valor #4:»; mientras que la función fmt.Scanf() lee el valor ingresado por el usuario y lo almacena en la variable valor. Con la función append() añadimos cada valor al array pasando dos argumentos que corresponden al nombre del array y el nombre de la variable que contiene el valor a añadir.

Seleccionando opción y mostrando el resultado
fmt.Println("\nSelecciones una de las siguientes opciones")
fmt.Println("------------------------------------------")
fmt.Println("1) Ordenar de mayor a menor")
fmt.Println("2) Ordenar de menor a mayor")
fmt.Println("------------------------------------------")
fmt.Print("Opcion: ")
fmt.Scanf("%d", &opt)

switch opt {
case 1:
    ordenarMayor(listNum, cant)
case 2:
    ordenarMenor(listNum, cant)
default:
    fmt.Println("Opcion no valida!!")

Las 5 primeras funciones fmt.Println() 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. La función fmt.Print() en la línea #6 solo muestra la palabra «Opcion: » y con la función fmt.Scanf() leemos la opción ingresada por el usuario.

La sentencia switch toma la variable opt y evalúa la opción que el usuario escogió y dependiendo de esto entonces llama a la función ordenarMayor() u ordenarMenor() que recibe 2 parametros, el primero es el array dinámico y el segundo es la cantidad de elementos que posee dicho array.

Ejecutando nuestro programa

Al ejecutar este pequeño programa nos da un resultado similar al siguiente:

[fixedtorres@linuxero]$ go run OrdenarArrayDinamico.go
¿Cuantos valores desea ingresar?: 5
Ingrese en valor #1: 1992
Ingrese en valor #2: 1957
Ingrese en valor #3: 1810
Ingrese en valor #4: 2017
Ingrese en valor #5: 2002

Selecciones una de las siguientes opciones
------------------------------------------
1) Ordenar de mayor a menor
2) Ordenar de menor a mayor
------------------------------------------
Opcion: 2

Array dinamico ordenado: [1810][1957][1992][2002][2017]
[fixedtorres@linuxero]$ 

Un array ordenado de menor a mayor si seleccionamos la opción #2.



Añadir un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *