La notion d'algorithme

Inventer une machine de Turing chaque fois qu'on désire décrire un système informationnel serait une tâche rédhibitoire, et bien peu opérationnelle. C'est un instrument théorique fort utile, mais cette "machine" n'a rien de réel. Elle sert en fait à formaliser la notion intuitive de programme tel qu’on en a parlé au paragraphe précédent. Il existe une manière de décrire (ou d'écrire) des programmes beaucoup plus opérationnelle,

puisqu'elle peut se mettre en œuvre immédiatement sur un ordinateur. Ce sont les algorithmes46_{. L'écriture d'un}

algorithme est équivalent à la construction d'une machine de Turing, pour réaliser le même traitement de l'information. Un algorithme est la "spécification d'un schéma de calcul, sous forme d'une suite finie d'opérations élémentaires obéissant à un enchaînement déterminé" (définition de l'Encyclopedia Universalis citée dans

46

Le mot "algorithme" vient du nom d'un mathématicien perse al-Khowâ-rismî, dont l'ouvrage donnait des règles d'arithmétique sur la représentation décimale des nombres et montrait l'inutilité des tables et abaques.

[Froidevaux 90]). Il décrit un traitement sur un certain nombre d'informations (de données) en composant un nombre fini d'opérations simples, rigoureusement définies et pouvant être effectivement réalisées par une machine (ou par l'esprit humain). On distingue donc les structures de données qui sont les représentations des informations à traiter, et les structures de contrôle, qui sont les opérations à effectuer sur ces données. Les structures de données peuvent être considérées comme un codage de l'information, au sens défini au chapitre 1, et les structures de contrôle sont exprimées par des mots simples du langage courant, bien qu'on puisse en fournir une description mathématique très formalisée.

Décrivons un algorithme équivalent au programme élaboré au paragraphe précédent grâce aux machines de Turing. Codons d'abord les informations nécessaires toujours de la même manière : 100 pour le rouge, 010 pour l'orange et 001 pour le vert. On notera X un "espace mémoire" (ou une variable) qui stocke le message reçu

du système de feux de circulation. On représente cette réception de message par l'écriture X Message (X reçoit

"Message"). L'action à effectuer sera donc différente selon le contenu du message. Cela peut s'écrire de la manière suivante : X Message Si X = 100 Alors "Arrêter" Sinon Si X = 010 Alors "Ralentir" Sinon Si X = 001 Alors "Passer"

Cet algorithme décrit bien la situation informationnelle des feux de circulation. En le regardant de près, on peut lui trouver quelques imperfections. D'abord, l'avant dernière ligne est redondante : il est en effet clair que si on (ou la machine) arrive à cette ligne, c'est que le message n'est ni 100, ni 010, donc nécessairement 001. On peut donc supprimer les deux dernières instructions Si et Alors. Ensuite, au niveau de l'espace mémoire occupé (la variable X), on s'aperçoit qu'on pourrait réduire cet espace en codant le message sur deux bits (cf. Figure 1.3 du chapitre 1). Mais on peut encore faire mieux en n'utilisant qu'un espace mémoire d'un seul bit : il suffit en effet de stocker le début du message c’est-à-dire son premier chiffre, si c'est 1, alors c'est le rouge, si c'est 0, il suffit de lire le chiffre suivant pour reconnaître le message, si c'est 1 alors c'est l'orange, si c'est 0 alors c'est le vert. On reconnaît ici le programme qui a été décrit par la machine de Turing du paragraphe précédent. Ce programme se décrit donc par l'algorithme suivant :

X début(Message) Si X = 1 Alors "Arrêter" Sinon X (suivant(Message) Si X = 1 Alors "Ralentir" Sinon "Passer"

Cette description n'est pas unique, et on peut écrire d'autres algorithmes pour obtenir exactement le même traitement de l'information, par exemple :

X début(Message) Si X = 0 Alors X (suivant(Message) Si X = 1 Alors "Ralentir" Sinon "Passer" Sinon "Arrêter"

On remarque dans ce dernier exemple l'intérêt de décaler l'écriture (ce qu'on appelle "l'indentation") pour bien repérer les blocs imbriqués dans les structures de contrôle. On voit aussi que l'écriture (et la lecture) d'un algorithme peut devenir très rapidement une tâche extrêmement compliquée.

Nous allons donner maintenant un autre algorithme, totalement différent, mais qui réalise le même traitement. On verra qu'il est susceptible de s'étendre à un message plus compliqué et qu'il amène à une nouvelle réflexion sur la complexité. Le message reçu est codé sur trois bits. Numérotons ces bits de 1 à 3, on notera i la

variable désignant le numéro du bit considéré, on notera m(i) le ième bit du message. On a, dans le système de

m(1) m(2) m(3)

Arrêter 1 0 0

Ralentir 0 1 0

Passer 0 0 1

On peut donc découvrir la nature du message en lisant chaque bit, et en s'arrêtant dès qu'on a lu un 1. Le message est identifié par la place où on a lu le 1. Cette procédure se décrit par l'algorithme suivant :

i 1 X m(1)

Tant que X différent de 1 X m(i+1) i i+1 Si i = 1 Alors "Arrêter" Si i = 2 Alors "Ralentir" Sinon "Passer"

Vérifions que cet algorithme fonctionne bien, car il est plus compliqué à comprendre que ceux écrits précédemment (ce qui prouve qu'on peut faire des algorithmes parfois plus compliqués qu'il n'est nécessaire !).

1) Supposons que le feu est rouge, donc que le message envoyé est 100. X reçoit la valeur m(1) qui est 1, et i reçoit la valeur 1 également. L'instruction "Tant que" ne s'exécute pas, puisque X=1, donc on passe à l'instruction suivante. Comme i=1 c'est la première instruction qui s'exécute, on obtient donc "Arrêter"

2) Supposons que le feu est orange, donc que le message envoyé est 010. X reçoit la valeur m(1) qui est 0, et i reçoit la valeur 1. L'instruction "Tant que" va s'exécuter ici pour une première fois, donc X reçoit m(2) qui est 1 et i reçoit la valeur 2. Ensuite, l'instruction "Tant que" ne s'exécute plus puisque X=1, on passe à l'instruction suivante. Comme i= 2, c'est la deuxième instruction "Si" qui s'exécute, on obtient donc "Ralentir"

3) Supposons que le feu est vert, donc que le message envoyé est 001. X reçoit la valeur m(1) qui est 0, et i reçoit la valeur 1. L'instruction "Tant que" va s'exécuter ici pour une première fois, donc X reçoit m(2) qui est 0 et i reçoit la valeur 2. Puisque X = 0, l'instruction "Tant que" s'exécute alors une seconde fois, donc X reçoit m(3) qui est 1 et i reçoit la valeur 3. Ensuite, l'instruction "Tant que" ne s'exécute plus puisque X=1, on passe à l'instruction suivante. Comme i= 3, les deux instructions "Si" ne peuvent s'exécuter, on obtient donc "Passer"