# Chapitre 1 — Comprendre les algorithmes et les algorigrammes
## Introduction
Ce premier chapitre est dédié aux fondements de la programmation ! Avant de pouvoir écrire du code efficace et robuste, il est essentiel de maîtriser la pensée algorithmique. Ce chapitre vous introduira aux concepts fondamentaux des algorithmes et à leur représentation visuelle : les algorigrammes. Ces outils sont indispensables pour structurer votre pensée et concevoir des solutions logiques à des problèmes complexes, des compétences clés pour tout ingénieur.
> [!note] Pourquoi est-ce important ?
> Les algorithmes sont partout : dans votre smartphone, les systèmes de navigation, les moteurs de recherche, les systèmes bancaires, et même les recettes de cuisine ! En tant qu'ingénieur, vous serez amené à concevoir, analyser et optimiser des algorithmes pour résoudre des problèmes concrets dans divers domaines.
Nous poserons ici les bases qui vous seront cruciales pour les cours d'Algorithmique plus avancés et pour des applications pratiques comme la manipulation de bases de données avec SQL.
## 1. Qu'est-ce qu'un Algorithme ?
Le terme "algorithme" est souvent utilisé, mais sa définition précise est fondamentale.
> [!definition] Définition d'un Algorithme
> Un **algorithme** est une suite finie et non ambiguë d'instructions ou d'opérations permettant de résoudre un problème donné ou d'accomplir une tâche spécifique. Il prend des données en entrée, effectue une série de traitements et produit des données en sortie.
### 1.1. Caractéristiques Fondamentales d'un Algorithme
Pour qu'une suite d'instructions soit qualifiée d'algorithme, elle doit respecter plusieurs propriétés essentielles :
> [!theorem] Propriétés d'un Algorithme
> 1. **Finitude :** L'algorithme doit se terminer après un nombre fini d'étapes. Il ne doit pas boucler indéfiniment.
> 2. **Déterminisme :** Pour un même ensemble de données d'entrée, l'algorithme doit toujours produire le même résultat. Chaque étape doit être définie de manière univoque.
> 3. **Effectivité :** Chaque instruction de l'algorithme doit être réalisable en un temps fini et par des moyens concrets (par exemple, par un ordinateur).
> 4. **Entrées (Inputs) :** L'algorithme doit spécifier les données qu'il prend en entrée. Ces données sont les informations initiales nécessaires à son exécution.
> 5. **Sorties (Outputs) :** L'algorithme doit produire un ou plusieurs résultats en sortie, qui correspondent à la solution du problème.
> [!example] Exemple simple : La recette de cuisine
> Une recette de cuisine est une excellente analogie d'un algorithme :
> - **Entrées :** Ingrédients (farine, œufs, sucre, etc.).
> - **Instructions :** "Mélanger les œufs et le sucre", "Ajouter la farine progressivement", "Cuire 30 minutes à 180°C".
> - **Finitude :** La recette se termine quand le plat est prêt.
> - **Déterminisme :** Si vous suivez la recette exactement, vous obtiendrez toujours le même plat (en théorie !).
> - **Effectivité :** Chaque étape est réalisable.
> - **Sortie :** Le plat fini.
## 2. Les Algorigrammes : Représentation Visuelle des Algorithmes
Décrire un algorithme uniquement par du texte peut rapidement devenir lourd et difficile à suivre. Les algorigrammes (ou organigrammes de programmation) offrent une solution graphique pour représenter la logique d'un algorithme.
> [!definition] Définition d'un Algorigramme
> Un **algorigramme** est une représentation graphique d'un algorithme, utilisant un ensemble standardisé de symboles géométriques pour dépeindre les différentes étapes, les décisions et le flux d'exécution.
### 2.1. Symboles Standards des Algorigrammes
La norme internationale ISO 5807 (ou ANSI X3.5 aux États-Unis) définit les symboles à utiliser. Voici les principaux :
| Symbole (Forme) | Nom | Description |
| :------------------ | :-------------- | :------------------------------------------------------------------------------------------------------ |
| **Ovale** | **Début/Fin** | Indique le point de départ et le point d'arrêt de l'algorithme. |
| **Rectangle** | **Traitement** | Représente une opération ou un ensemble d'opérations (calcul, affectation de variable, etc.). |
| **Parallélogramme** | **Entrée/Sortie** | Représente une opération d'entrée de données (lecture) ou de sortie de données (affichage). |
| **Losange** | **Décision** | Représente un test logique où le flux d'exécution se divise en fonction d'une condition (Oui/Non, Vrai/Faux). |
| **Petit Cercle** | **Connecteur** | Utilisé pour relier des parties de l'algorigramme situées à différents endroits (sur la même page ou entre pages). |
| **Flèche** | **Flèche de Flux** | Indique le sens d'exécution de l'algorithme. |
> [!warning] Attention aux symboles !
> Il est crucial d'utiliser les symboles corrects pour chaque type d'opération. Un rectangle pour une entrée/sortie est une erreur courante qui peut rendre votre algorigramme ambigu.
### 2.2. Règles de Construction d'un Algorigramme
Pour garantir la clarté et la conformité, suivez ces règles :
> [!theorem] Règles de Construction
> 1. **Un seul début, une seule fin :** Un algorigramme doit toujours commencer par un symbole "Début" et se terminer par un symbole "Fin".
> 2. **Sens de lecture :** Le flux d'exécution se fait généralement de haut en bas et de gauche à droite. Les flèches de flux sont essentielles pour indiquer le chemin.
> 3. **Clarté et concision :** Chaque symbole doit contenir une description claire et concise de l'opération. Évitez les descriptions trop longues.
> 4. **Connexions :** Toutes les flèches de flux doivent connecter deux symboles.
> 5. **Sorties de décision :** Un symbole de décision doit toujours avoir au moins deux sorties, chacune étiquetée (ex: "Vrai"/"Faux", "Oui"/"Non").
## 3. Les Structures Algorithmiques de Base
Tous les algorithmes, quelle que soit leur complexité, peuvent être construits à partir de trois structures de contrôle de base. La maîtrise de ces structures est fondamentale.
### 3.1. La Séquence
> [!definition] Séquence
> La structure **séquentielle** est la plus simple : les instructions sont exécutées les unes après les autres, dans l'ordre où elles apparaissent.
**Algorithme textuel (pseudo-code) :**
```
Instruction 1
Instruction 2
Instruction 3
```
**Algorigramme :**
```mermaid
graph TD
start([Début]) --> inst1[Instruction 1]
inst1 --> inst2[Instruction 2]
inst2 --> inst3[Instruction 3]
inst3 --> fin([Fin])
```
> [!example] Exemple : Calcul de la somme de deux nombres
> **Algorithme :**
> 1. DÉBUT
> 2. LIRE A
> 3. LIRE B
> 4. SOMME $\leftarrow$ A + B
> 5. AFFICHER SOMME
> 6. FIN
>
> **Algorigramme :**
> ```mermaid
> graph TD
> start([Début]) --> readA[/Lire A/]
> readA --> readB[/Lire B/]
> readB --> process[Somme = A + B]
> process --> display[/Afficher Somme/]
> display --> fin([Fin])
> ```
### 3.2. L'Alternative (ou Conditionnelle)
> [!definition] Alternative
> La structure **alternative** permet d'exécuter un bloc d'instructions *si* une condition est vraie, et éventuellement un autre bloc d'instructions *si* la condition est fausse.
**Algorithme textuel (pseudo-code) :**
```
SI (Condition) ALORS
Bloc d'instructions 1
SINON
Bloc d'instructions 2
FIN SI
```
*(Le `SINON` est optionnel pour une alternative simple.)*
**Algorigramme :**
```mermaid
graph TD
start([Début]) --> condition{Condition ?}
condition -- Vrai --> bloc1[Bloc d'instructions 1]
condition -- Faux --> bloc2[Bloc d'instructions 2]
bloc1 --> endIf(Fin Si)
bloc2 --> endIf
endIf --> suite([Suite de l'algorithme])
```
> [!example] Exemple : Déterminer si un nombre est positif
> **Algorithme :**
> 1. DÉBUT
> 2. LIRE Nombre
> 3. SI (Nombre > 0) ALORS
> 4. AFFICHER "Le nombre est positif."
> 5. SINON
> 6. AFFICHER "Le nombre est négatif ou nul."
> 7. FIN SI
> 8. FIN
>
> **Algorigramme :**
> ```mermaid
> graph TD
> start([Début]) --> readN[/Lire Nombre/]
> readN --> isPositive{Nombre > 0 ?}
> isPositive -- Oui --> printPositive[/Afficher "Positif"/]
> isPositive -- Non --> printNegative[/Afficher "Négatif ou Nul"/]
> printPositive --> fin([Fin])
> printNegative --> fin(Fin)
> ```
### 3.3. La Répétition (ou Boucle)
> [!definition] Répétition
> La structure de **répétition** (ou boucle) permet d'exécuter un bloc d'instructions plusieurs fois, tant qu'une condition est vraie ou pour un nombre défini de fois.
Il existe plusieurs types de boucles :
#### 3.3.1. Boucle TANT QUE (While)
> [!definition] Boucle TANT QUE
> La boucle **TANT QUE** exécute un bloc d'instructions *tant qu'* une condition est vraie. La condition est testée *avant* chaque exécution du bloc. Si la condition est fausse dès le début, le bloc n'est jamais exécuté.
**Algorithme textuel (pseudo-code) :**
```
TANT QUE (Condition) FAIRE
Bloc d'instructions
FIN TANT QUE
```
**Algorigramme :**
```mermaid
graph TD
start([Début]) --> condition{Condition ?}
condition -- Vrai --> bloc[Bloc d'instructions]
bloc --> condition
condition -- Faux --> suite([Suite de l'algorithme])
```
> [!example] Exemple : Compter de 1 à 5
> **Algorithme :**
> 1. DÉBUT
> 2. Compteur $\leftarrow$ 1
> 3. TANT QUE (Compteur $\le$ 5) FAIRE
> 4. AFFICHER Compteur
> 5. Compteur ← Compteur + 1
> 6. FIN TANT QUE
> 7. FIN
>
> **Algorigramme :**
> ```mermaid
> graph TD
> start([Début]) --> init[Compteur = 1]
> init --> condition{Compteur <= 5 ?}
> condition -- Vrai --> display[/Afficher Compteur/]
> display --> increment[Compteur = Compteur + 1]
> increment --> condition
> condition -- Faux --> fin([Fin])
> ```
#### 3.3.2. Boucle RÉPÉTER... TANT QUE (Do-While)
> [!definition] Boucle RÉPÉTER... TANT QUE
> La boucle **RÉPÉTER... TANT QUE** exécute un bloc d'instructions *au moins une fois*, puis répète l'exécution *jusqu'à ce qu'* une condition devienne fausse. La condition est testée *après* l'exécution du bloc.
**Algorithme textuel (pseudo-code) :**
```
DO
Bloc d'instructions
WHILE (Condition)
```
**Algorigramme :**
```mermaid
graph TD
start(Début) --> bloc[Bloc d'instructions]
bloc --> condition{Condition ?}
condition -- Vrai --> bloc
condition -- Faux --> suite[Suite de l'algorithme]
```
#### 3.3.3. Boucle POUR (For)
> [!definition] Boucle POUR
> La boucle **POUR** est utilisée lorsqu'on connaît à l'avance le nombre de répétitions ou lorsqu'on veut itérer sur une séquence de valeurs. Elle initialise un compteur, définit une condition de fin et une incrémentation.
**Algorithme textuel (pseudo-code) :**
```
POUR Compteur DE ValeurInitiale À ValeurFinale PAS DE Pas FAIRE
Bloc d'instructions
```
**Algorigramme :**
(Pour la simplicité et la conformité aux symboles de base, la boucle POUR peut être représentée comme une boucle TANT QUE avec les éléments d'initialisation et d'incrémentation intégrés.)
```mermaid
graph TD
start(Début) --> init[Initialiser Compteur]
init --> condition{Compteur <= ValeurFinale ?}
condition -- Vrai --> block[Bloc d'instructions]
block --> increment[Compteur = Compteur + Pas]
increment --> condition
condition -- Faux --> fin(Fin)
```
> [!example] Exemple : Calculer la somme des N premiers entiers
> **Algorithme :**
> 1. DÉBUT
> 2. LIRE N
> 3. Somme $\leftarrow$ 0
> 4. POUR i DE 1 À N FAIRE
> 5. Somme ← Somme + i
> 6. AFFICHER Somme
> 7. FIN
>
> **Algorigramme :**
> ```mermaid
> graph TD
> start(Début) --> readN[/Lire N/]
> readN --> initSum[Somme = 0]
> initSum --> initI[i = 1]
> initI --> condition{i <= N ?}
> condition -- Vrai --> addSum[Somme = Somme + i]
> addSum --> incrementI[i = i + 1]
> incrementI --> condition
> condition -- Faux --> display[/Afficher Somme/]
> display --> fin(Fin)
> ```
## 4. Exercices Pratiques et Exemples Détaillés
Pour solidifier votre compréhension, voici quelques exercices à résoudre. Essayez de les concevoir d'abord en pseudo-code, puis de les traduire en algorigramme.
### 4.1. Exercice 1 : Calcul de Factorielle
> [!example] Problème : Calculer la factorielle d'un nombre entier positif $N$.
> La factorielle de $N$, notée $N!$, est le produit de tous les entiers positifs inférieurs ou égaux à $N$. Par exemple, $5! = 5 \times 4 \times 3 \times 2 \times 1 = 120$. Par convention, $0! = 1$.
>
> **Algorithme (pseudo-code) :**
> ```
> DÉBUT
> LIRE N
> SI N < 0 ALORS
> {
> AFFICHER "Erreur : N doit être positif ou nul."
> }
> SINON
> {
> SI N = 0 ALORS
> {
> Factorielle = 1
> }
> SINON
> {
> Factorielle = 1
> POUR i DE 1 À N FAIRE
> {
> Factorielle = Factorielle * i
> }
> }
> }
> AFFICHER "La factorielle de ", N, " est ", Factorielle
> FIN
> ```
>
> **Algorigramme :**
> ```mermaid
> graph TD
> start(Début) --> readN[/Lire N/]
> readN --> checkNegative{N < 0 ?}
> checkNegative -- Oui --> error[/Afficher "Erreur: N positif ou nul"/]
> checkNegative -- Non --> checkZero{N = 0 ?}
> checkZero -- Oui --> factIsOne[Factorielle = 1]
> checkZero -- Non --> initFactLoop[Factorielle = 1]
> initFactLoop --> initI[i = 1]
> initI --> loopCondition{i <= N ?}
> loopCondition -- Vrai --> multiply[Factorielle = Factorielle * i]
> multiply --> incrementI[i = i + 1]
> incrementI --> loopCondition
> loopCondition -- Faux --> displayFact[/Afficher Factorielle/]
> error --> fin(Fin)
> factIsOne --> displayFact
> displayFact --> fin(Fin)
> ```
### 4.2. Exercice 2 : Conversion de Température
> [!example] Problème : Convertir une température de Celsius en Fahrenheit.
> La formule de conversion est : $F = C \times \frac{9}{5} + 32$.
>
> **Algorithme (pseudo-code) :**
> ```
> DÉBUT
> LIRE TemperatureCelsius
> TemperatureFahrenheit = TemperatureCelsius * (9/5) + 32
> AFFICHER TemperatureFahrenheit
> FIN
> ```
>
> **Algorigramme :**
> ```mermaid
> graph TD
> start([Début]) --> readC[/Lire TemperatureCelsius/]
> readC --> calculateF["TemperatureFahrenheit = TemperatureCelsius × (9/5) + 32"]
> calculateF --> displayF[/Afficher TemperatureFahrenheit/]
> displayF --> fin([Fin])
> ```
## 5. Transition vers la Programmation
Les algorigrammes et le pseudo-code sont des étapes intermédiaires cruciales entre la compréhension d'un problème et l'écriture du code source dans un langage de programmation spécifique (Python, Java, C, etc.).
> [!note] L'importance de la conception
> Un bon algorithme est la fondation d'un bon programme. En concevant d'abord la logique avec un algorigramme, vous pouvez identifier et corriger les erreurs logiques avant même d'écrire une ligne de code. Cela économise un temps précieux en phase de développement et de débogage.
Lorsque vous passerez à l'écriture de code, vous verrez que les structures de base (séquence, conditionnelle, répétition) se traduisent directement dans tous les langages de programmation.
Par exemple, la condition `SI (Condition) ALORS ... SINON ... ` deviendra `if (condition) { ... } else { ... }` en C/Java, ou `if condition: ... else: ...` en Python.
Pour les cours futurs sur l'**Algorithmique**, vous approfondirez les notions de complexité, d'efficacité et de choix des meilleures structures de données. Pour **SQL Débutant**, vous appliquerez des principes algorithmiques pour filtrer, trier et agréger des données dans des bases de données, par exemple en utilisant des conditions (`WHERE`) ou des boucles logiques implicites dans les opérations de jointure ou d'agrégation.
# 🗓️ Historique
> **Dernière mise à jour :** `01 novembre 2025`
> **Rédigé par :** [[Julien DUQUENNOY]]