Algoritmos y estructuras de datos en Kotlin: guía completa

Entrenador de Python en Línea para Principiantes

Aprende Python fácilmente sin sobrecargarte de teoría. Resuelve tareas prácticas con verificación automática, recibe pistas y escribe código directamente en el navegador, sin instalar nada.

Start Course

Introducción a algoritmos y estructuras de datos en Kotlin

Kotlin es un lenguaje de programación moderno que combina concisión y potencia. El estudio de algoritmos y estructuras de datos en Kotlin abre el camino para escribir código eficiente y escalable. Ya sea que desarrolles aplicaciones Android, servicios backend o programas de escritorio, comprender las estructuras básicas y los algoritmos es una habilidad obligatoria para cualquier desarrollador profesional.

En este artículo, analizaremos las estructuras de datos y algoritmos clave en Kotlin con ejemplos prácticos de código. Aprenderás cómo implementar ordenamiento, búsqueda, trabajo con listas, pilas, colas, árboles y grafos.

1. Estructuras de datos básicas en Kotlin

1.1. Arreglos y listas

En Kotlin, los arreglos están representados por el tipo Array, y las listas dinámicas por List y MutableList. Las listas son la estructura de datos más utilizada.

fun main() {    // Lista inmutable    val list: List<Int> = listOf(1, 2, 3, 4, 5)        // Lista mutable    val mutableList: MutableList<Int> = mutableListOf(10, 20, 30)    mutableList.add(40)    mutableList.removeAt(0)        println(mutableList) // [20, 30, 40]}

1.2. Pila (Stack)

La pila funciona bajo el principio LIFO (Last In, First Out). En Kotlin, se puede implementar una pila usando ArrayDeque.

fun stackExample() {    val stack = ArrayDeque<String>()        stack.addLast("Primero")    stack.addLast("Segundo")    stack.addLast("Tercero")        println(stack.removeLast()) // Tercero    println(stack.removeLast()) // Segundo    println(stack.removeLast()) // Primero}

1.3. Cola (Queue)

La cola funciona bajo el principio FIFO (First In, First Out). La implementación también usa ArrayDeque.

fun queueExample() {    val queue = ArrayDeque<Int>()        queue.addLast(1)    queue.addLast(2)    queue.addLast(3)        println(queue.removeFirst()) // 1    println(queue.removeFirst()) // 2    println(queue.removeFirst()) // 3}

1.4. Lista enlazada (LinkedList)

La lista enlazada es una secuencia de nodos, cada uno de los cuales contiene datos y una referencia al siguiente nodo. Implementamos una lista simplemente enlazada simple.

class Node<T>(var value: T, var next: Node<T>? = null)

class LinkedList<T> {    private var head: Node<T>? = null        fun add(value: T) {        val newNode = Node(value)        if (head == null) {            head = newNode        } else {            var current = head            while (current?.next != null) {                current = current.next            }            current?.next = newNode        }    }        fun printAll() {        var current = head        while (current != null) {            print("${current.value} ")            current = current.next        }        println()    }}

fun main() {    val list = LinkedList<Int>()    list.add(10)    list.add(20)    list.add(30)    list.printAll() // 10 20 30}

2. Algoritmos de ordenamiento en Kotlin

2.1. Ordenamiento de burbuja (Bubble Sort)

Algoritmo simple pero ineficiente. Complejidad O(n²).

fun bubbleSort(arr: MutableList<Int>) {    val n = arr.size    for (i in 0 until n - 1) {        for (j in 0 until n - i - 1) {            if (arr[j] > arr[j + 1]) {                val temp = arr[j]                arr[j] = arr[j + 1]                arr[j + 1] = temp            }        }    }}

fun main() {    val numbers = mutableListOf(64, 34, 25, 12, 22, 11, 90)    bubbleSort(numbers)    println(numbers) // [11, 12, 22, 25, 34, 64, 90]}