Algorithme d'Euclide - Définition

Introduction

L'algorithme d'Euclide est un algorithme permettant de déterminer le plus grand commun diviseur (P.G.C.D.) de deux entiers dont on ne connaît pas la factorisation. Il est déjà décrit dans le livre VII des Éléments d'Euclide.

Dans la tradition grecque, en comprenant un nombre entier comme une longueur, un couple d'entiers comme un rectangle, leur PGCD est la longueur du côté du plus grand carré permettant de carreler entièrement ce rectangle. L'algorithme décompose ce rectangle en carrés, de plus en plus petits, par divisions euclidiennes successives, de la longueur par la largeur, puis de la largeur par le reste, jusqu'à un reste nul.

Dans le rectangle de dimensions L=21 par l=15 ci-dessous, par exemple, on peut glisser un carré de côté 15 mais il reste un rectangle de côtés 15 et 6, dans lequel on peut glisser deux carrés de côté 6 mais il reste un rectangle de côtés 6 et 3 que l'on peut carreler entièrement de carrés de côté 3. Les carrés de côté 6 ou 15 peuvent aussi se carreler en carrés de côté 3. Le rectangle entier peut se carreler en carrés de côté 3. Il n'existe pas de carré plus grand permettant un tel carrelage.

Cet algorithme repose sur la structure d'anneau euclidien de l'anneau des entiers relatifs, plus particulièrement sur la propriété de division euclidienne. Il se généralise donc à bien d'autres anneaux, en particulier les anneaux de polynômes à coefficients dans un corps. L'algorithme se généralise pour permettre le calcul des coefficients de Bezout.

L'algorithme est effectif à condition de disposer d'un algorithme effectif de division euclidienne. La possibilité de disposer d'un tel algorithme rend de nombreux autres calculs effectifs, notamment, en algèbre linéaire, le calcul de facteurs invariants.

Remarque préliminaire

Puisque l'algorithme a pour objet le calcul d'un PGCD, il est possible de se restreindre aux entiers positifs, un PGCD de deux entiers relatifs étant égal au PGCD de leurs valeurs absolues.

Remarque historique

Au début, Euclide a formulé le problème de façon géométrique : comment trouver une « unité de mesure » commune pour deux longueurs de segments. Il procède par soustractions répétées de la longueur du plus court segment sur la longueur du plus long. Cela correspond à une adaptation de la méthode naïve de calcul de la division euclidienne, telle que décrite dans l'article consacré.

Description de l'algorithme

Soient deux entiers naturels a et b, dont on cherche le PGCD. Le cas où a ou b est nul ne nécessite aucun algorithme ; on l'exclut. Une suite d'entiers (a_n)_n est définie par récurrence de pas 2, plus précisément par divisions euclidiennes successives ; la suite est initialisée par a₀ = a,a₁ = b, puis propagée par la règle de récurrence : tant que a_{n + 1} est non nul, a_{n + 2} est défini comme le reste de la division euclidienne de a_n par a_{n + 1}.

On commence donc par calculer le reste de la division de a par b, qu'on note r ; puis on remplace a par b, puis b par r, et on réapplique le procédé depuis le début.

On obtient ainsi une suite, qui vaut 0 à un certain rang ; le PGCD cherché est le dernier reste non nul.

Exemple

Calculons, par exemple, le PGCD de 1071 et de 1029 à l'aide de l'algorithme d'Euclide :

1071 = 1029 × 1 + 42

1029 = 42 × 24 + 21

42 = 21 × 2 + 0

Il faut prendre le dernier reste avant le zéro, donc PGCD(1071 ; 1029) = 21

Exemples d'implémentations

Voici différents exemples d'implémentations de l'algorithme d'Euclide en programmation.

Pseudocode

Fonction PGCD(a:nombre, b:nombre):nombre

      Si b=0 alors      | Retourner a      Sinon      | r egal au reste de la division entière (modulo) de a par b      | Retourner PGCD(b, r)      

Python

      def PGCD(a, b):          if b == 0:              return a          else:              reste = a % b              return PGCD(b, reste)      

C

      int PGCD(int a, int b)      {          if (b == 0)              return a;          else              return PGCD(b, a % b);      }      

ou sous forme condensée:

      int PGCD(int a, int b)      {          return (b)?PGCD(b, a%b):a;      }      

ou en utilisant une boucle, sans rappeler la fonction dans elle-même (algorithme ressemblant plus à l'organigramme à flèche présent sur l'article):

      int PGCD(int a, int b)      {           int r = a%b;           while (r != 0)           {             a = b;             b = r;             r = a%b;           }           return b;      }