Article original : Learn Data Structures and Algorithms – Introduction and Learning Resources

Les structures de données et les algorithmes (DSA) sont un aspect important de tout langage de programmation. Chaque langage a ses propres structures de données et sa manière de gérer différents types d'algorithmes.

Ainsi, en tant que programmeur, peu importe le langage de programmation avec lequel vous travaillez, les structures de données et les algorithmes doivent être un aspect important de votre programmation quotidienne. C'est parce que nous en avons toujours besoin pour résoudre des problèmes complexes.

Et c'est pourquoi j'ai rédigé cet article – pour vous montrer ce que sont les structures de données et les algorithmes, et pour partager avec vous quelques ressources pour vous aider à les apprendre dans divers langages.

Ce que nous allons couvrir

Qu'est-ce que les structures de données et les algorithmes ?

Les structures de données et les algorithmes vont de pair. Vous pouvez avoir un ensemble de données arrangé dans une certaine structure que vous passez ensuite dans un algorithme pour l'exécuter d'une certaine manière.

Mais les structures de données et les algorithmes ne sont pas les mêmes choses. Alors regardons-les séparément.

Qu'est-ce qu'une structure de données ?

Une structure de données est une manière particulière d'arranger les données afin qu'elles puissent être sauvegardées en mémoire et récupérées pour une utilisation ultérieure.

Si vous souhaitez lire un guide approfondi sur les structures de données en JavaScript, consultez ce tutoriel.

Exemples de structures de données

Les données peuvent être n'importe quoi qui peut être sauvegardé. Cela pourrait être des types primitifs comme les chaînes de caractères, les booléens, les entiers ou les flottants. Ou des types non primitifs comme les tableaux, les listes chaînées, les arbres, les piles et les files d'attente.

Ci-dessous se trouve un exemple de liste chaînée, de pile et de file d'attente en Python :

Voici le code pour une liste chaînée :

# Liste chaînée
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class My_linkedlist:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
            return
        last_node = self.head
        while last_node.next:
            last_node = last_node.next
        last_node.next = new_node

    def print_list(self):
        current_node = self.head
        while current_node:
            print(current_node.data)
            current_node = current_node.next

linked_list = My_linkedlist()
linked_list.append("Liste des jours de la semaine à partir du début :")
linked_list.append("Lundi")
linked_list.append("Mardi")
linked_list.append("Mercredi")
linked_list.append("Jeudi")
linked_list.append("Vendredi")
linked_list.print_list()

"""
Sortie :
Jours de la semaine :
Lundi
Mardi
Mercredi
Jeudi
Vendredi
"""

print()
print()

Vous pouvez lire plus sur les listes chaînées en Python ici.

Voici le code pour une pile :

# Pile
class My_stack:
    def __init__(self):
        self.stack = []

    def push(self, data):
        self.stack.append(data)

    def pop(self):
        return self.stack.pop()

    def is_empty(self):
        return len(self.stack) == 0

    def peek(self):
        return self.stack[-1]

stack = My_stack()
stack.push("Lundi")
stack.push("Mardi")
stack.push("Mercredi")
stack.push("Jeudi")
stack.push("Vendredi")
stack.push("Dépiler les jours de la semaine à partir du dernier :")
print(stack.pop())
print(stack.pop())
print(stack.pop())
print(stack.pop())
print(stack.pop())
print(stack.pop())

"""
Sortie :
Dépiler les jours de la semaine à partir du dernier :
Vendredi
Jeudi
Mercredi
Mardi
Lundi
"""

print()
print()

Voici une vidéo sur la façon d'utiliser la structure de données de pile pour résoudre des défis de codage.

Et voici le code pour une file d'attente :

# File d'attente
from collections import deque

class My_queue:
    def __init__(self):
        self.queue = deque()

    def enqueue(self, data):
        self.queue.append(data)

    def dequeue(self):
        return self.queue.popleft()

    def is_empty(self):
        return len(self.queue) == 0

    def peek(self):
        return self.queue[0]

queue = My_queue()
queue.enqueue("File d'attente des jours de la semaine :")
queue.enqueue("Lundi")
queue.enqueue("Mardi")
queue.enqueue("Mercredi")
queue.enqueue("Jeudi")
queue.enqueue("Vendredi")
print(queue.dequeue())
print(queue.dequeue())
print(queue.dequeue())
print(queue.dequeue())
print(queue.dequeue())
print(queue.dequeue())

"""
Sortie :
File d'attente des jours de la semaine :
Lundi
Mardi
Mercredi
Jeudi
Vendredi
"""

Et voici un article sur la structure de données de file d'attente en Java si vous souhaitez lire plus.

Les exemples ci-dessus sont les plus courants que vous pouvez trouver dans presque tous les langages de programmation disponibles. Chaque langage de programmation a sa propre manière d'implémenter ces structures de données.

Dans le même ordre d'idées, chaque langage de programmation a ses propres structures de données qui lui sont exclusives. Par exemple, Python a des types de données uniques comme les tuples, les listes et les dictionnaires :

Voici comment vous écrivez un tuple en Python :

# tuple en python
person_tuple = ("John Smith", 26, "Python Engineer")

Voici un exemple de liste :

# liste en python
fruits_list = ["apple", "orange", "Cashew", "Mango"]

Voici un article qui compare les tuples et les listes en Python pour vous aider à comprendre comment ils fonctionnent et quelles sont leurs principales différences.

Et voici un dictionnaire :

# dictionnaire en python
person = {"name": "John Doe", "age": 28, "occupation": "Software Developer"}

Voici un guide des dictionnaires en Python - ce qu'ils sont et comment travailler avec eux.

Et en JavaScript, nous avons des ensembles, des objets et sa propre manière d'implémenter des tableaux :

// Set en JavaScript
const uniqueFruits = new Set(["Mango", "Cashew", "Strawberry", "Coconut", "Mango"]);

// Array en JavaScript
const sportsArray = ["Football", "Tennis", "Athletics", "Badminton"];

// Object en JavaScript
const player = { name: "Enzo Fernandez", age: 22, sport: "Footballer", club: "Chelsea", country: "Argentina" };

Ce sont tous des exemples de structures de données que nous pouvons utiliser pour travailler avec nos données.

Si vous souhaitez apprendre les structures de données d'un ingénieur Google, voici un cours que vous pourriez apprécier.

Maintenant, regardons les algorithmes.

Qu'est-ce qu'un algorithme ?

En programmation, un algorithme est un ensemble d'étapes pour résoudre un problème connu. Les problèmes résolus par un algorithme pourraient être le tri d'un ensemble de données, la recherche dans les données disponibles, ou même le chiffrement des données.

Types d'algorithmes

Il existe un certain nombre de types d'algorithmes disponibles aujourd'hui. Il n'y a pas de manière particulière de caractériser les types, mais il existe des catégories larges comme les algorithmes de tri et de recherche.

Des exemples d'algorithmes de tri sont le tri par fusion, le tri à bulles, le tri par sélection, et autres. Et des exemples d'algorithmes de recherche sont la recherche exponentielle, la recherche binaire, la recherche par saut, et autres.

Il existe d'autres types d'algorithmes comme le hachage, les algorithmes de salutation, les algorithmes de force brute, et plus.

Voici un exemple d'algorithme de tri à bulles en Python :

# Tri à bulles en Python
def bubble_sort(arr):
    n = len(arr)

    for i in range(n):
        for j in range(0, n-i-1):

            if arr[j] < arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]

    return arr

arr = [10, 8, 9, 5, 7, 6, 3, 2, 1, 4]

print("Tableau en ordre décroissant :", bubble_sort(arr))
# Tableau en ordre décroissant : [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

Voici un article avec plus d'exemples si vous souhaitez lire plus.

Et voici un exemple d'algorithme de recherche binaire en Python :

def binary_search_demo(arr, x):
    low = 0
    high = len(arr) - 1
    mid = 0

    while low <= high:
        mid = (high + low) // 2

        if arr[mid] < x:
            low = mid + 1
        elif arr[mid] > x:
            high = mid - 1
        else:
            return mid
    return -1

arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
x = 9

result = binary_search_demo(arr, x)

if result != -1:
    print("L'élément est présent à l'index", result)
else:
    print("L'élément n'est pas présent dans le tableau")

# Sortie : L'élément est présent à l'index 8

Voici un tutoriel approfondi sur la recherche binaire en Python si vous souhaitez en apprendre plus.

Dans quel langage devrais-je écrire des algorithmes ?

Vous pouvez écrire des algorithmes avec n'importe quel langage de programmation. Chaque langage de programmation a sa manière d'implémenter un algorithme particulier.

À la fin de la journée, peu importe le langage que vous utilisez, un algorithme reste un algorithme. Par exemple, vous pouvez implémenter un algorithme de tri à bulles ou tout autre type d'algorithme avec n'importe quel langage de programmation.

Mais dans certains cas, le choix d'un langage pour écrire un algorithme dépend du langage de programmation exact que vous utilisez dans votre projet.

Si vous développez une solution web et que vous utilisez déjà PHP ou Node JS, alors vous devrez peut-être écrire l'algorithme dont vous avez besoin en PHP ou en JavaScript.

Comment apprendre les algorithmes

La première étape vers l'apprentissage des algorithmes commence lorsque vous commencez à apprendre un langage de programmation.

À ce stade, les fondamentaux sont très importants car il n'y a aucun moyen de comprendre des concepts de codage complexes sans eux.

Si vous apprenez le développement web, par exemple, vous devez bien comprendre le HTML, le CSS et les bases de JavaScript.

La prochaine chose à faire est de dépasser les bases et de bien comprendre les structures de données. C'est parce que, à de nombreuses occasions, vous passerez diverses données dans un algorithme en tant qu'entrée.

Vous pouvez ensuite aborder les aspects théoriques de l'algorithme. Ceux-ci incluent ce qu'est un algorithme et les différents types d'algorithmes.

Après avoir compris la théorie, la prochaine étape est la pratique. Apprenez à implémenter divers algorithmes, puis continuez à pratiquer jusqu'à ce que vous les compreniez.

Ressources pour apprendre les algorithmes

Voici plusieurs ressources vidéo et textuelles en ligne pour apprendre les algorithmes :

Si vous commencez tout juste avec JavaScript, le programme de certification JavaScript Algorithms and Data Structures Certification de freeCodeCamp serait un excellent point de départ.

Voici quelques vidéos de la chaîne YouTube freeCodeCamp qui peuvent vous aider à apprendre les algorithmes :

Conclusion

Cet article vous a guidé à travers :

  • ce que sont les structures de données et les algorithmes
  • quelques types avec des exemples de structures de données et d'algorithmes en Python et JavaScript
  • les types collectifs de structures de données en programmation
  • comment apprendre les algorithmes
  • et les ressources pour apprendre les algorithmes.

Si vous souhaitez apprendre les algorithmes, vous devriez consulter les ressources fournies dans cet article. Elles sont un bon point de départ pour apprendre les algorithmes dans les langages dans lesquels elles sont disponibles.

Merci d'avoir lu.