Algorithmes et structures de données en Kotlin : guide complet pour débutants

Introduction : pourquoi étudier les algorithmes et structures de données en Kotlin ?

Kotlin est un langage de programmation moderne, concis et sûr, activement utilisé pour le développement Android, les services backend et même les applications de bureau. Mais savoir écrire du code en Kotlin n'est que la moitié du chemin. Pour devenir un véritable bon développeur, il faut comprendre comment fonctionnent les algorithmes et les structures de données.

Pourquoi un débutant en a-t-il besoin ? Premièrement, la connaissance des structures de base (listes, piles, files d'attente, tables de hachage) aide à écrire un code plus efficace et plus rapide. Deuxièmement, les algorithmes sont la base pour résoudre des problèmes techniques lors des entretiens. Troisièmement, c'est tout simplement intéressant : vous commencez à voir la logique et les mathématiques derrière le code.

Dans cet article, nous allons passer en revue les algorithmes et structures de données clés en Kotlin à partir de zéro. Tous les exemples seront simples, compréhensibles et prêts à être exécutés. C'est parti !

1. Structures de données de base en Kotlin

Tableaux et listes

Kotlin propose deux types principaux de collections : Array (taille fixe) et List (dynamique). Pour la plupart des tâches, il est plus pratique d'utiliser List.

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

    // Liste modifiable    val mutableList = mutableListOf(10, 20, 30)    mutableList.add(40)    println("Liste après ajout : $mutableList")

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

Pile (Stack)

La pile fonctionne selon le principe LIFO (Last In, First Out) — le dernier entré est le premier sorti. Kotlin n'a pas de classe Stack intégrée, mais elle est facile à implémenter avec 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("Élément du dessus : ${stack.peek()}") // 3    println("On retire : ${stack.pop()}")        // 3    println("Maintenant le dessus : ${stack.peek()}")  // 2}

File d'attente (Queue)

La file d'attente fonctionne selon le principe FIFO (First In, First Out) — le premier entré est le premier sorti. En Kotlin, il est pratique d'utiliser LinkedList de Java pour cela.

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("Premier")    queue.enqueue("Deuxième")    queue.enqueue("Troisième")

    println("On sert : ${queue.dequeue()}") // Premier    println("Suivant : ${queue.peek()}")      // Deuxième}

2. Algorithmes de tri en Kotlin

Tri à bulles (Bubble Sort)

Algorithme simple mais lent. Adapté à l'apprentissage, mais pas pour des projets réels.

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("Trié par bulles : $list")}

Bi