Ordenar Array Dinámico con Kotlin

Este pequeño programa de apenas 59 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 básicamente es un contenedor de elementos no ordenados de un solo tipo con un tamaño flexible, puede incrementarse o reducirse en tiempo de ejecución cuando se agregan elementos o se eliminan.

Código fuente
fun ordenarMayor(listNum: ArrayList<Int>, cant: Int) {
    var tmp = 0
    for(x in 0 until cant) {
        for(y in 0 until cant) {
            if(listNum[x] > listNum[y]) {
                tmp = listNum[x]
                listNum[x] = listNum[y]
                listNum[y] = tmp
            }
        }
    }
    println("\nArray ordenado: $listNum")
}

fun ordenarMenor(listNum: ArrayList<Int>, cant: Int) {
    var tmp = 0
    for(x in 0 until cant) {
        for(y in 0 until cant) {
            if(listNum[x] < listNum[y]) {
                tmp = listNum[y]
                listNum[y] = listNum[x]
                listNum[x] = tmp
            }
        }
    }
    println("\nArray ordenado: $listNum")
}

fun main(Args: Array<String>) {
    val listNum = arrayListOf<Int>()
    var cant: Int
    var opt: Int
    var valor: Int

    print("¿Cuantos valores desea ingresar?: ")
    cant = readLine()!!.toInt()

    for(v in 1..cant) {
        print("Ingrese el valor #$v: ")
        valor = readLine()!!.toInt()
        listNum.add(valor)
    }

    println("\n" + """
        Selecciones una de las siguientes opciones
        ------------------------------------------
        1) Ordenar de mayor a menor
        2) Ordenar de menor a mayor
        ------------------------------------------
    """.trimIndent())
    print("Seleccione una opcion: ")
    opt = readLine()!!.toInt()

    when(opt) {
        1 -> ordenarMayor(listNum, cant)
        2 -> ordenarMenor(listNum, cant)
        else -> "Opcion no valida!!"
    }
}




Función ordenarMayor()
fun ordenarMayor(listNum: ArrayList<Int>, cant: Int) {
    var tmp = 0
    for(x in 0 until cant) {
        for(y in 0 until cant) {
            if(listNum[x] > listNum[y]) {
                tmp = listNum[x]
                listNum[x] = listNum[y]
                listNum[y] = tmp
            }
        }
    }
    println("\nArray ordenado: $listNum")
}

La función ordenarMayor() recibe dos parámetros, el primero es el array que deseamos ordenar y el segundo es la cantidad de elementos que contiene el array. Esta función ordena el array de mayor a menor.

Variable tmp
var tmp = 0

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() + bucle for() anidado
for(x in 0 until cant) {
    for(y in 0 until cant) {
        if(listNum[x] > listNum[y]) {
            tmp = listNum[x]
            listNum[x] = listNum[y]
            listNum[y] = tmp
        }
    }
}

Ambos bucles van a iterar sobre un rango desde 0 hasta cant, sin contar el último valor del rango. El bucle externo va a iterar una sola vez por cada elemento del array en la posición x; mientras que el bucle interno va a repetir la misma iteración 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(), 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 que 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.

Mostrando el array dinámico ordenado
println("\nArray ordenado: $listNum")

Por último mostramos en pantalla el array ordenado con la función println(), la expresión ${listNum} se le llama interpolación de strings y consiste en reemplazar la expresión entre llaves “{}” por el contenido en ella.

Función ordenarMenor()
fun ordenarMenor(listNum: ArrayList<Int>, cant: Int) {
    var tmp = 0
    for(x in 0 until cant) {
        for(y in 0 until cant) {
            if(listNum[x] < listNum[y]) {
                tmp = listNum[y]
                listNum[y] = listNum[x]
                listNum[x] = tmp
            }
        }
    }
    println("\nArray ordenado: $listNum")
}

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()
fun main(Args: Array<String>) {
    val listNum = arrayListOf<Int>()
    var cant: Int
    var opt: Int
    var valor: Int

    print("¿Cuantos valores desea ingresar?: ")
    cant = readLine()!!.toInt()

    for(v in 1..cant) {
        print("Ingrese el valor #$v: ")
        valor = readLine()!!.toInt()
        listNum.add(valor)
    }

    println("\n" + """
        Selecciones una de las siguientes opciones
        ------------------------------------------
        1) Ordenar de mayor a menor
        2) Ordenar de menor a mayor
        ------------------------------------------
    """.trimIndent())
    print("Seleccione una opcion: ")
    opt = readLine()!!.toInt()

    when(opt) {
        1 -> ordenarMayor(listNum, cant)
        2 -> ordenarMenor(listNum, cant)
        else -> "Opcion no valida!!"
    }
}

Al igual que en C++, Go, Java y otros lenguajes, en Kotlin la función main() es obligatoria. Es la única función que es llamada cuando se ejecuta el programa y todo lo que se encuentro dentro de ella será ejecutado, el unico parametro que lleva es un array de strings.

Creando Array Dinámico
val listNum = arrayListOf<Int>()

Creamos el array usando la función arrayListOf<>() e indicando el tipo de elementos que va a almacenar, en este caso será un array con elementos de tipo Int. Así de sencillo en Kotlin.

Creando variables
var cant: Int
var opt: Int
var valor: Int

Creamos 3 variables de tipo Int requeridas para recibir y procesar los 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 y leyendo cantidad de valores
print("¿Cuantos valores desea ingresar?: ")
cant = readLine()!!.toInt()

Con la función print() le solicitamos al usuario que le indique al programa cuántos valores desea ingresar en el array y luego leemos dicho dato con la función readLine(), pero hay que convertirlo a tipo Int con la función .toInt() antes de realizar algún tipo de operación. Entre estas dos últimas funciones se encuentran los signos «!!», le indican al compilador que no se va a ingresar algún valor null. Más información en readLine().

Bucle for(), agregando elementos al array
for(v in 1..cant) {
    print("Ingrese el valor #$v: ")
    valor = readLine()!!.toInt()
    listNum.add(valor)
}

El bucle va a iterar sobre un rango que va desde 1 hasta cant. La función print() solo imprime un mensaje informando al usuario que ingrese un valor junto con el número de valores que se va ingresando con la expresión $v; por ejemplo, “Ingrese el elemento #3”. Leemos dicho dato con la función readLine(), pero hay que convertirlo a tipo Int con la función .toInt() antes de realizar algún tipo de operación.

Seleccionando opción y mostrando resultado
println("\n" + """
    Selecciones una de las siguientes opciones
    ------------------------------------------
    1) Ordenar de mayor a menor
    2) Ordenar de menor a mayor
    ------------------------------------------
""".trimIndent())
print("Opcion: ")
opt = readLine()!!.toInt()

when(opt) {
    1 -> ordenarMayor(listNum, cant)
    2 -> ordenarMenor(listNum, cant)
    else -> "Opcion no valida!!"
}

La función print() solo nos muestra algo como esto:

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

Un pequeño menú que le indica al usuario que seleccione 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.

print("Seleccione una opcion: ")
opt = readLine()!!.toInt()

Con la función print() solo le solicitamos al usuario que selecciones una opción y luego leemos el número de la opción seleccionada con la función readLine(), pero hay que convertirlo a tipo Int con la función .toInt() antes de realizar algún tipo de operación.

La sentencia when() 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 compilar y ejecutar nuestro programa, nos dara un resultamos similar a este:

[fixedtorres@linuxero]$ kotlin OrdenarArrayDinamico.jar
¿Cuantos valores desea ingresar?: 5
Ingrese el valor #1: 1993
Ingrese el valor #2: 182
Ingrese el valor #3: 12389
Ingrese el valor #4: 128
Ingrese el valor #5: 321

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

Array ordenado: [12389, 1993, 321, 182, 128]
[fixedtorres@linuxero]$

Un array ordenado de menor a mayor si seleccionamos la opción #1. Para saber más sobre cómo compilar código Kotlin desde la terminal, diríjase a este link.


Deja un comentario

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