Algoritmos e estruturas de dados em Kotlin: guia prático

Algoritmos e Estruturas de Dados em Kotlin: Da Teoria à Prática

Kotlin é uma linguagem de programação moderna que combina a concisão do Python com o poder do Java. Para escrever código eficiente, você precisa entender como algoritmos e estruturas de dados funcionam. Neste artigo, vamos detalhar conceitos-chave usando exemplos em Kotlin que ajudarão você a escrever programas rápidos e confiáveis.

O material será útil tanto para iniciantes quanto para desenvolvedores que desejam sistematizar seus conhecimentos. Todos os exemplos podem ser executados no ambiente IntelliJ IDEA ou em um compilador online.

1. Estruturas de Dados Básicas em Kotlin

A biblioteca padrão do Kotlin fornece um rico conjunto de estruturas de dados. Vamos analisar as principais.

Listas (List, MutableList)

Listas são coleções ordenadas de elementos. Kotlin separa listas mutáveis e imutáveis.

fun main() {    // Lista imutável    val fruits = listOf("Apple", "Banana", "Orange")        // Lista mutável    val numbers = mutableListOf(1, 2, 3)    numbers.add(4)    numbers.removeAt(1)        println(fruits[0]) // Apple    println(numbers)   // [1, 3, 4]}

Conjuntos (Set, MutableSet)

Conjuntos armazenam elementos únicos. Eles são úteis para verificar duplicatas.

fun main() {    val uniqueNumbers = setOf(1, 2, 2, 3, 3, 3)    println(uniqueNumbers) // [1, 2, 3]        val mutableSet = mutableSetOf("a", "b")    mutableSet.add("c")    println(mutableSet.contains("b")) // true}

Mapas (Map, MutableMap)

Mapas armazenam pares chave-valor. Um análogo de uma tabela hash.

fun main() {    val capitals = mapOf(        "Russia" to "Moscow",        "USA" to "Washington",        "France" to "Paris"    )        println(capitals["Russia"]) // Moscow        // Mapa mutável    val scores = mutableMapOf("Ivan" to 85)    scores["Maria"] = 92    scores["Ivan"] = 90}

2. Implementação de Estruturas de Dados Clássicas

Às vezes, as estruturas padrão não são suficientes. Vamos ver como implementar uma pilha e uma fila manualmente.

Pilha (Stack)

Uma pilha funciona no princípio LIFO (Último a Entrar, Primeiro a Sair). É usada em parsers, ações de desfazer e travessia de grafos.

class Stack<T> {    private val elements = mutableListOf<T>()        fun push(item: T) = elements.add(item)    fun pop(): T? = if (isEmpty()) null else elements.removeAt(elements.size - 1)    fun peek(): T? = elements.lastOrNull()    fun isEmpty() = elements.isEmpty()    fun size() = elements.size}

fun main() {    val stack = Stack<Int>()    stack.push(10)    stack.push(20)    stack.push(30)        println(stack.pop())   // 30    println(stack.peek())  // 20    println(stack.size())  // 2}

Fila (Queue)

Uma fila funciona no princípio FIFO (Primeiro a Entrar, Primeiro a Sair). É usada em sistemas de processamento de tarefas.

class Queue<T> {    private val elements = mutableListOf<T>()        fun enqueue(item: T) = elements.add(item)    fun dequeue(): T? = if (isEmpty()) null else elements.removeAt(0)    fun peek(): T? = elements.firstOrNull()    fun isEmpty() = elements.isEmpty()}

fun main() {    val queue = Queue<String>()    queue.enqueue("Task 1")    queue.enqueue("Task 2")    queue.enqueue("Task 3")        println(queue.dequeue()) // Task 1    println(queue.peek())    // Task 2}

3. Algoritmos de Ordenação em Kotlin

Ordenação é uma operação básica. Vamos detalhar três algoritmos populares.

QuickSort

Um dos algoritmos mais eficientes com complexidade média de O(n log n).

fun quickSort(arr: IntArray, low: Int, high: Int) {    if (low < high) {        val pi = partition(arr, low, high)        quickSort(arr, low, pi - 1)        quick