Quelques algorithmes fondamentaux sur les vecteurs

Dans la suite, on note les variables de façon différente selon qu'elles sont passées à la fonction par
adresse ou par valeur. Lors du codage dans un langage de programmation X, il convient d'adapter ces
conventions à la syntaxe du langage utilisé. En particulier, si le langage utilisé est le C++, le passage
par adresse peut prendre deux formes : pointeur ou référence (à noter, pas de passage par référence
en C).

Remarques :

1/ dans les langages utilisés, les indices varient à partir de la valeur 0, cette convention est utilisée
dans la suite,

2/ le type des éléments des vecteurs peut être quelconque ; dans la suite, on désigne par T le type de
ces éléments. Il est important de noter que les notations supposent que tous les opérateurs sont
utilisables avec tout type T, ce qui n'est pas toujours vrai (c'est faux en particulier pour les chaînes de
caractères au sens C, de même que pour String en Java) : comparer l'exemple utilisant le type string
et le type (char *) pour effectuer le même traitement.

3/ dans certains cas, en C/C++, on peut choisir, pour des raisons d'efficacité du code des passages de
paramètres différents de ceux utilisés ici. A préciser lors des TP,

4/ l'utilisation d'un "for" est bien adapté au traitement des vecteurs, l'utilisation d'un "tantque" est
toutefois préférée au niveau algorithmique à cause des variantes trop nombreuses de représentation
d'un schéma "pour".

Partie I : vecteurs non triés

1/ Parcours

algo vide Parcours_Vecteur (adr T v[], val entier n)

var
val entier i;

début

i Ù 0;
tantque (i < n)
// un traitement quelconque sur l'élément courant
i Ù i + 1;
fintq;

fin; // Parcours_Vecteur

2/ Accès en position k : trivial

Algorithmes vecteurs 12/2006 1/5

3/ Accès associatif (ou par valeur)

On recherche dans un vecteur v de n éléments la position (indice) d'une valeur val. La fonction
retourne la position de val dans v si cette valeur est présente, -1 sinon.

algo vide Acces_Associatif_Vecteur (adr T v[], val entier n, val T val)

var
val entier i;

début

i Ù 0;
tantque (i < n)
si (v[i] = val)
retourner i;
finsi;
i Ù i + 1;
fintq;

retourner -1;

fin; // Acces_Associatif_Vecteur

4/ Insertion en position k dans un vecteur

On cherche à insérer dans un vecteur v de n éléments une valeur valins en position k. La fonction
retourne vrai si l'insertion a pu être réalisée. Le nombre d'éléments de v est modifié en fin d'action : la
vérification que le vecteur peut comporter 1 élément supplémentaire est laissée à la fonction
appelante (donc au programmeur si utilisation d'un vecteur statique en C/C++).

algo logique Insertion_Position_Vecteur

(adr T v[], adr entier n, val T valins, val entier k)
var
val entier i;

début

si (( k < 0) ou ((k > n))

retourner faux;
finsi;
si (k = n)
v[n] = valins;
n Ù n + 1;
retourner vrai;
finsi;
i Ù n;
tantque (i ³ k)
v[i] Ù v[i-1]
i Ù i - 1;
fintq;
v[k] Ù valins;
n Ù n + 1;

retourner vrai;

fin; // Insertion_Position_Vecteur

Algorithmes vecteurs 12/2006 2/5

5/ Insertion associative dans un vecteur

On cherche à insérer dans un vecteur v de n éléments une valeur valins après un élément de valeur
apres.

Mêmes hypothèses que pour 4.

algo logique Insertion_Associative_Vecteur

(adr T v[], adr entier n, val T valins, val T apres)
var
val entier k;

début

k Ù Acces_Associatif_Vecteur (v, n, apres);

si (k = -1)
retourner faux;
finsi;
sinon
retourner Insertion_Position_Vecteur (v, n, valins, k+1);
finsi;

fin; // Insertion_Associative_Vecteur

6/ Suppression en position k dans un vecteur

On cherche à supprimer dans un vecteur v de n éléments l'élément situé en position k. La fonction

retourne vrai si la suppression a pu être réalisée. Le nombre d'éléments de v est modifié en fin
d'action.

algo logique Suppression_Position_Vecteur

(adr T v[], adr entier n, val entier k)
var
val entier i;

début

si (( k < 0) ou ((k > n))

retourner faux;
finsi;
si (k = n-1)
n Ù n - 1;
retourner vrai;
finsi;
i Ù k;
tantque (i < n)
v[i] Ù v[i+1]
i Ù i + 1;
fintq;
n Ù n - 1;

retourner vrai;

fin; // Suppression_Position_Vecteur

Algorithmes vecteurs 12/2006 3/5

7/ Suppression associative dans un vecteur

On cherche à supprimer dans un vecteur v de n éléments une valeur valsup. Le nombre d'éléments
de v est modifié en fin d'action.

algo logique Suppression_Associative_Vecteur

(adr T v[], adr entier n, val T valsup)
var
val entier k;

début

k Ù Acces_Associatif_Vecteur (v, n, valsup);

si (k = -1)
retourner faux;
finsi;
sinon
retourner Suppresssion_Position_Vecteur (v, n, k);
finsi;

fin; // Suppression_Associative_Vecteur

Exemple de codage de ces fonctions en C++ avec des vecteurs dont les éléments sont de type
différent (entiers, chaînes C, string) : voir répertoire C++

Remarque : des conventions de type JAVADOC sont utilisées (on pourrait générer de la
documentation programme C++ par Javadoc).

Algorithmes vecteurs 12/2006 4/5

Partie II : vecteurs triés
L'avantage de disposer d'un vecteur trié est que, outre l'accès séquentiel, il est possible de faire un
accès dichotomique ("binary search"), ce qui améloiore considérablement les performances pour
l'accès à l'information (qui est l'un des traitements les plus utilisés dans les applications nformatiques).

Pour rappel :

Accès séquentiel : O (n)

Accès dichotomique : O (log2 (n))

Dans le cas d'un accès séquentiel, la structure de données dans laquelle s'effectue la recherche
comporte au départ n éléments, après le premier accès, il reste (au plus) n-1 éléments à examiner,
après l'accès suivant, il reste (au plus) n-2 éléments ; de façon générale, après k accès, il reste (au
plus) n-k éléments à examiner.
Dans le cas d'un accès dichotomique, la structure de données (qui ne peut être dans ce cas qu'un
vecteur trié) dans laquelle s'effectue la recherche comporte au départ n éléments, après le premier
accès, il reste (au plus) n/2 éléments à examiner, après l'accès suivant, il reste (au plus) n/4
éléments ; de façon générale, après k accès, il reste (au plus) n/2 k éléments à examiner.

Exemple pour un vecteur comportant 1024 éléments :

Accès séquentiel ; cas favorable : 1 accès ; cas défavorable : 1024 ; en moyenne : 512.
Accès dichotomique ; cas favorable : 1 accès ; cas défavorable : au maximum 10.

Reste à pouvoir utiliser un vecteur trié : de nombreux algorithmes de tri ont été développés, certains
seront présentés dans le module Algorithmique II.

Accès dichotomique dans un vecteur trié

algo entier Acces_Dichotomique_Vecteur
(adr T v[], val entier n, val T cherche)
var
val entier inf,
sup,
mil;

début

si ((v[0] £ cherche) et (cherche £ v[n-1]))

inf Ù 0;
sup Ù n-1;
tantque (inf £ sup)
mil Ù (inf+sup) / 2;
si (v[mil] = cherche)
retourner mil;
sinon si (v[mil] < cherche)
inf Ù mil + 1;
sinon
sup Ù mil - 1;
finsi;
fintq;
finsi;

retourner -1;

fin; // Acces_Dichotomique_Vecteur

Algorithmes vecteurs 12/2006 5/5