Algorithmen und Datenstrukturen in Kotlin: Ein vollständiger Leitfaden für Anfänger

Einleitung: Warum Algorithmen und Datenstrukturen in Kotlin lernen?

Kotlin ist eine moderne, prägnante und sichere Programmiersprache, die aktiv für die Entwicklung von Android-, Backend- und sogar Desktop-Anwendungen eingesetzt wird. Aber Code in Kotlin schreiben zu können, ist nur die halbe Miete. Um ein wirklich guter Entwickler zu werden, muss man verstehen, wie Algorithmen und Datenstrukturen funktionieren.

Warum ist das für Anfänger wichtig? Erstens hilft das Wissen über grundlegende Strukturen (Listen, Stapel, Warteschlangen, Hash-Tabellen), effizienteren und schnelleren Code zu schreiben. Zweitens sind Algorithmen die Grundlage für die Lösung technischer Aufgaben in Vorstellungsgesprächen. Drittens ist es einfach interessant: Man beginnt, hinter dem Code Logik und Mathematik zu sehen.

In diesem Artikel werden wir die wichtigsten Algorithmen und Datenstrukturen in Kotlin von Grund auf behandeln. Alle Beispiele sind einfach, verständlich und lauffertig. Los geht's!

1. Grundlegende Datenstrukturen in Kotlin

Arrays und Listen

In Kotlin gibt es zwei Haupttypen von Sammlungen: Array (feste Größe) und List (dynamisch). Für die meisten Aufgaben ist die Verwendung von List praktischer.

fun main() {    // Array fester Größe    val numbersArray = arrayOf(1, 2, 3, 4, 5)    println("Array: ${numbersArray.joinToString()}")

    // Veränderbare Liste    val mutableList = mutableListOf(10, 20, 30)    mutableList.add(40)    println("Liste nach dem Hinzufügen: $mutableList")

    // Unveränderbare Liste    val immutableList = listOf(100, 200, 300)    println("Unveränderbare Liste: $immutableList")}

Stapel (Stack)

Ein Stapel funktioniert nach dem LIFO-Prinzip (Last In, First Out) – der letzte, der hereinkommt, geht zuerst wieder raus. Kotlin hat keine eingebaute Stack-Klasse, aber sie lässt sich leicht mit MutableList implementieren.

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("Oberstes Element: ${stack.peek()}") // 3    println("Entfernen: ${stack.pop()}")        // 3    println("Jetzt oberstes: ${stack.peek()}")  // 2}

Warteschlange (Queue)

Eine Warteschlange funktioniert nach dem FIFO-Prinzip (First In, First Out) – der erste, der hereinkommt, geht auch zuerst wieder raus. In Kotlin verwendet man dafür bequem die Java-LinkedList.

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("Erster")    queue.enqueue("Zweiter")    queue.enqueue("Dritter")

    println("Bedienen: ${queue.dequeue()}") // Erster    println("Nächster: ${queue.peek()}")      // Zweiter}

2. Sortieralgorithmen in Kotlin

Bubble Sort

Ein einfacher, aber langsamer Algorithmus. Geeignet zum Lernen, aber nicht für reale Projekte.

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("Mit Bubble Sort sortiert: $list")}

Bi