Algorithmen und Datenstrukturen in Kotlin: Das vollständige Handbuch

Einführung in Algorithmen und Datenstrukturen mit Kotlin

Kotlin ist eine moderne Programmiersprache, die Prägnanz und Leistungsfähigkeit vereint. Das Erlernen von Algorithmen und Datenstrukturen mit Kotlin eröffnet den Weg zum Schreiben von effizientem und skalierbarem Code. Unabhängig davon, ob Sie Android-Apps, Backend-Dienste oder Desktop-Programme entwickeln, ist das Verständnis grundlegender Strukturen und Algorithmen eine unverzichtbare Fähigkeit für jeden professionellen Entwickler.

In diesem Artikel werden wir die wichtigsten Datenstrukturen und Algorithmen in Kotlin mit praktischen Codebeispielen durchgehen. Sie erfahren, wie Sie Sortierung, Suche, die Arbeit mit Listen, Stapeln, Warteschlangen, Bäumen und Graphen implementieren.

1. Grundlegende Datenstrukturen in Kotlin

1.1. Arrays und Listen

In Kotlin werden Arrays durch den Typ Array und dynamische Listen durch List und MutableList repräsentiert. Listen sind die am häufigsten verwendete Datenstruktur.

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

1.2. Stapel (Stack)

Ein Stapel arbeitet nach dem LIFO-Prinzip (Last In, First Out). In Kotlin kann ein Stapel mit ArrayDeque implementiert werden.

fun stackExample() {    val stack = ArrayDeque<String>()        stack.addLast("Erster")    stack.addLast("Zweiter")    stack.addLast("Dritter")        println(stack.removeLast()) // Dritter    println(stack.removeLast()) // Zweiter    println(stack.removeLast()) // Erster}

1.3. Warteschlange (Queue)

Eine Warteschlange arbeitet nach dem FIFO-Prinzip (First In, First Out). Die Implementierung verwendet ebenfalls 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. Verkettete Liste (LinkedList)

Eine verkettete Liste ist eine Folge von Knoten, von denen jeder Daten und einen Verweis auf den nächsten Knoten enthält. Wir implementieren eine einfache einfach verkettete Liste.

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. Sortieralgorithmen in Kotlin

2.1. Bubble Sort

Ein einfacher, aber ineffizienter Algorithmus. Komplexität 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