Algoritmos e Estruturas de Dados em Kotlin: Guia Completo

Introdução a Algoritmos e Estruturas de Dados em Kotlin

Kotlin é uma linguagem de programação moderna que combina concisão e poder. Estudar algoritmos e estruturas de dados em Kotlin abre caminho para escrever código eficiente e escalável. Independentemente de você estar desenvolvendo aplicativos Android, serviços de backend ou programas desktop, entender as estruturas básicas e algoritmos é uma habilidade obrigatória para qualquer desenvolvedor profissional.

Neste artigo, vamos analisar as principais estruturas de dados e algoritmos em Kotlin com exemplos práticos de código. Você aprenderá como implementar ordenação, busca, trabalho com listas, pilhas, filas, árvores e grafos.

1. Estruturas de Dados Básicas em Kotlin

1.1. Arrays e Listas

Em Kotlin, arrays são representados pelo tipo Array, e listas dinâmicas por List e MutableList. Listas são a estrutura de dados mais utilizada.

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

1.2. Pilha (Stack)

A pilha funciona pelo princípio LIFO (Last In, First Out). Em Kotlin, pode-se implementar uma pilha usando ArrayDeque.

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

1.3. Fila (Queue)

A fila funciona pelo princípio FIFO (First In, First Out). A implementação também 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 Encadeada (LinkedList)

Lista encadeada é uma sequência de nós, cada um contendo dados e uma referência ao próximo nó. Vamos implementar uma lista simplesmente encadeada.

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 Ordenação em Kotlin

2.1. Bubble Sort

Algoritmo simples, mas ineficiente. Complexidade 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]}

2.2. Quick Sort