Swift sur LeetCode : comment améliorer ses algorithmes et résoudre des problèmes

Swift sur LeetCode : par où commencer et comment ne pas abandonner

Chaque développeur iOS se heurte tôt ou tard à un mur : tu réalises des projets, tu envoies des applications sur l'AppStore, mais lors de l'entretien, on te donne un problème sur un arbre binaire et tu es complètement bloqué. Ça te parle ? LeetCode est ce simulateur qui transforme « je fais juste de l'UI » en « je pense en algorithmes ». Mais il y a un hic : la plupart des solutions en ligne sont écrites en Python ou Java, alors que Swift est un langage avec sa propre philosophie. Dans cet article, nous allons voir comment résoudre efficacement des problèmes sur LeetCode spécifiquement en Swift, quelles structures de données utiliser et à quoi faire attention pour ne pas perdre de temps.

Cet article s'adresse à ceux qui connaissent déjà les bases de Swift mais souhaitent améliorer leur pensée algorithmique. Nous n'allons pas apprendre la syntaxe – nous allons apprendre à réfléchir.

Pourquoi Swift est un excellent choix pour LeetCode

Beaucoup pensent que Swift se limite à UIKit et SwiftUI, mais en réalité le langage offre des capacités puissantes pour les problèmes algorithmiques :

• Types optionnels – travail sécurisé avec nil sans crash inattendus.
• Value types (structures) – copie prévisible, pas de surprises avec les références.
• Calculs paresseux et approches fonctionnelles – map, filter, reduce simplifient grandement le code.
• Vitesse – Swift se compile en code natif, dépassant souvent Python de 2 à 3 fois.

Cependant, il y a aussi des pièges : par exemple, les tableaux en Swift sont des structures, et copier un grand tableau peut être coûteux. Mais nous en reparlerons séparément.

Structures de données : ce qu'il faut savoir pour Swift sur LeetCode

Avant de vous lancer dans la résolution de problèmes, assurez-vous de maîtriser les structures de base. Voici une liste incontournable pour Swift :

Tableaux et tranches (Array, ArraySlice)

Les tableaux en Swift ne sont pas de simples listes, mais des structures puissantes avec un accès en O(1) par index. Mais attention : l'insertion/suppression au début est en O(n). Utilisez ArraySlice pour éviter de copier les données lorsque vous travaillez avec des sous-tableaux.

let numbers = [1, 2, 3, 4, 5]let slice = numbers[1..<4] // ArraySlice, sans copieprint(slice) // [2, 3, 4]

Dictionnaires et ensembles (Dictionary, Set)

Pour les problèmes de comptage de fréquences, de recherche de doublons ou d'algorithmes à deux passages, ce sont vos meilleurs amis. Rappelez-vous : Dictionary est une table de hachage, O(1) en moyenne, mais peut dégrader à O(n) avec une mauvaise fonction de hachage.

func twoSum(_ nums: [Int], _ target: Int) -> [Int] {    var dict = [Int: Int]()    for (i, num) in nums.enumerated() {        if let j = dict[target - num] {            return [j, i]        }        dict[num] = i    }    return []}

Pile et file (Stack, Queue)

Swift n'a pas de structures de pile et de file intégrées, mais elles sont faciles à émuler avec un tableau. Pour une pile – append et popLast. Pour une file, utilisez ArraySlice ou une liste doublement chaînée pour éviter le O(n) lors du dequeue.

struct Stack<T> {    private var array = [T]()    mutating func push(_ element: T) { array.append(element) }    mutating func pop() -> T? { array.popLast() }    var isEmpty: Bool { array.isEmpty }}

Listes chaînées (Linked List)

LeetCode aime les problèmes sur les listes simplement chaînées. Swift n'a pas d'implémentation intégrée, mais vous pouvez définir une classe :

class ListNode {    var val: Int    var next: ListNode?    init(_ val: Int) { self.val = val; self.next = nil }}

C'est un classique pour les problèmes d'inversion de liste, de détection de cycle ou de suppression de nœud.

Patrons algorithmiques pour les problèmes Swift

Pour ne pas réinventer la roue à chaque fois, mémorisez quelques modèles qui couvrent 80% des problèmes sur LeetCode.

Deux pointeurs (Two Pointers)

I