Algoritmos e estruturas de dados em Kotlin: guia completo para iniciantes

Introdução: por que estudar algoritmos e estruturas de dados em Kotlin?

Kotlin é uma linguagem de programação moderna, concisa e segura, amplamente utilizada para desenvolvimento Android, serviços backend e até aplicações desktop. Mas saber escrever código em Kotlin é apenas metade do sucesso. Para se tornar um desenvolvedor verdadeiramente bom, é preciso entender como funcionam os algoritmos e estruturas de dados.

Por que um iniciante precisa disso? Primeiro, conhecer estruturas básicas (listas, pilhas, filas, tabelas hash) ajuda a escrever código mais eficiente e rápido. Segundo, algoritmos são a base para resolver problemas técnicos em entrevistas. Terceiro, é simplesmente interessante: você começa a ver a lógica e a matemática por trás do código.

Neste artigo, vamos abordar os principais algoritmos e estruturas de dados em Kotlin do zero. Todos os exemplos serão simples, compreensíveis e prontos para execução. Vamos lá!

1. Estruturas de dados básicas em Kotlin

Arrays e listas

Em Kotlin, existem dois tipos principais de coleções: Array (tamanho fixo) e List (dinâmica). Para a maioria das tarefas, é mais conveniente usar List.

fun main() {    // Array de tamanho fixo    val numbersArray = arrayOf(1, 2, 3, 4, 5)    println("Array: ${numbersArray.joinToString()}")

    // Lista mutável    val mutableList = mutableListOf(10, 20, 30)    mutableList.add(40)    println("Lista após adicionar: $mutableList")

    // Lista imutável    val immutableList = listOf(100, 200, 300)    println("Lista imutável: $immutableList")}

Pilha (Stack)

A pilha funciona pelo princípio LIFO (Last In, First Out) — o último a entrar é o primeiro a sair. Em Kotlin não há uma classe Stack nativa, mas é fácil implementá-la usando MutableList.

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(1)    stack.push(2)    stack.push(3)

    println("Elemento do topo: ${stack.peek()}") // 3    println("Removendo: ${stack.pop()}")        // 3    println("Agora o topo é: ${stack.peek()}")  // 2}

Fila (Queue)

A fila funciona pelo princípio FIFO (First In, First Out) — o primeiro a entrar é o primeiro a sair. Em Kotlin, é conveniente usar LinkedList do Java para isso.

import java.util.LinkedList

class Queue<T> {    private val elements = LinkedList<T>()

    fun enqueue(item: T) = elements.add(item)    fun dequeue(): T? = elements.poll()    fun peek(): T? = elements.peek()    fun isEmpty() = elements.isEmpty()    fun size() = elements.size}

fun main() {    val queue = Queue<String>()    queue.enqueue("Primeiro")    queue.enqueue("Segundo")    queue.enqueue("Terceiro")

    println("Atendendo: ${queue.dequeue()}") // Primeiro    println("Próximo: ${queue.peek()}")      // Segundo}

2. Algoritmos de ordenação em Kotlin

Bubble Sort (Ordenação por bolha)

Algoritmo simples, porém lento. Adequado para aprendizado, mas não para projetos reais.

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 list = mutableListOf(64, 34, 25, 12, 22, 11, 90)    bubbleSort(list)    println("Ordenado com bubble sort: $list")}

B