8PRO107 Éléments de programmation Les tableaux

Étude de cas 1 Description du problème : Lire une liste d’entiers et l’afficher d’abord dans le même ordre qu’elle a été lue puis dans l’ordre inverse. Spécification de l’entrée : Un entier 0 < n  500 suivi de n nombres entiers. Sortie : Deux listes d’entiers.

Étude de cas 1 Fonction principale variables n : entier instructions LIRE n SI (n  0 OU n > 500) ÉCRIRE « erreur dans les données » SINON {lire n entiers et les mettre en mémoire} {afficher les n valeurs dans l’ordre} {afficher les n valeurs dans l’ordre inverse}

Étude de cas 1 Comment mémoriser 500 valeurs ? Tableau : permet de déclarer un grand nombre de cases mémoire en utilisant un seul nom.

Étude de cas 1 Exemple : tableau d’entiers TAB de taille TAB[4] TAB[3] TAB[2] TAB[1] TAB[0] entier

Étude de cas 1 Exemple : tableau d’entiers TAB de taille TAB[4] TAB[3] TAB[2] TAB[1] TAB[0] entier TAB[1]  31

Étude de cas 1 Exemple : tableau d’entiers TAB de taille TAB[4] TAB[3] TAB[2] TAB[1] TAB[0] entier TAB[1]  31 POUR i  2 À 4, PAS DE 1 TAB[i]  i OU TAB[1]  31 i  2 TANT QUE i < 5 FAIRE TAB[i]  i i  i + 1

Étude de cas 1 Exemple : tableau de réels F de taille F[999] F[2] F[1] F[0] réel F[998]réel

Étude de cas 1 Exemple : tableau d’entiers Liste de taille Liste[499] Liste[2] Liste[1] Liste[0] entier Liste[498]entier

Étude de cas 1 Fonction principale variables n : entier Liste : tableau d’entiers de taille 500 instructions LIRE n SI ( n  0 OU n > 500 ) ALORS ÉCRIRE « erreur dans les données » SINON liretab (Liste, 0, n) ecriretab1 (Liste, 0, n) ecriretab2 (Liste, 0, n) FIN. où les trois fonctions satisfont les prototypes suivants : liretab (tableau d’entiers, entier, entier) ecriretab1 (tableau d’entiers, entier, entier) ecriretab2 (tableau d’entiers, entier, entier)

Étude de cas 1 Remarque Lorsqu’on passe un tableau en paramètre, il est toujours passé par référence et non par copie. Ainsi, on peut modifier le contenu d’un tableau en appelant une fonction. Nous verrons l’explication de ce comportement dans quelques semaines alors que nous étudierons les pointeurs.

Étude de cas 1 Fonction liretab prototype liretab ( tableau d’entiers T, entier debut, entier fin) variables entier i instructions i  debut TANT QUE ( i < fin ) FAIRE {lire le prochain entier et le placer à la i-ième position du tableau} {incrémenter i} But : Les valeurs lues ont été mises dans le tableau T de la position debut à la position fin.

Étude de cas 1 Fonction liretab prototype liretab ( tableau d’entiers T, entier debut, entier fin) variables entier i instructions i  debut TANT QUE ( i < fin ) FAIRE LIRE T[i] i  i + 1 But : Les valeurs lues ont été mises dans le tableau T de la position debut à la position fin.

Étude de cas 1 Fonction ecriretab1 prototype ecriretab1 (tableau d’entiers T, entier debut, entier fin) variables entier i instructions i  debut TANT QUE ( i < fin ) FAIRE ÉCRIRE T[i] i  i + 1 But : Les valeurs T[debut] à T[fin] ont été affichées.

Étude de cas 1 Fonction ecriretab2 prototype ecriretab2 (tableau d’entiers T, entier debut, entier fin) variables entier i instructions i  fin TANT QUE ( i > debut ) FAIRE i  i - 1 ÉCRIRE T[i] But : Les valeurs T[debut] à T[fin] ont été affichées.

Étude de cas 1 Pas-à-pas Entrée : Liste[499] Liste[2] Liste[1] Liste[0] entier n entier n tableau d’entiers Liste de taille 500

Étude de cas 1 Pas-à-pas Entrée : Liste[499] Liste[2] Liste[1] Liste[0] entier n LIRE n

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n appel de la fonction : liretab(Liste, 0, 3) 3 0 debut entier fin entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n liretab entier i 3 0 debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n liretab entier i i  debut debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n liretab entier i i  debut TANT QUE (i < fin) FAIRE LIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier liretab entier i i  debut TANT QUE (i < fin) FAIRE LIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier liretab entier i i  debut TANT QUE (i < fin) FAIRE LIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier liretab entier i i  debut TANT QUE (i < fin) FAIRE LIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier liretab entier i i  debut TANT QUE (i < fin) FAIRE LIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier liretab entier i i  debut TANT QUE (i < fin) FAIRE LIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier liretab entier i i  debut TANT QUE (i < fin) FAIRE LIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier liretab entier i i  debut TANT QUE (i < fin) FAIRE LIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier liretab entier i i  debut TANT QUE (i < fin) FAIRE LIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier liretab entier i i  debut TANT QUE (i < fin) FAIRE LIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : Liste[499] Liste[2] Liste[1] Liste[0] entier n entier retour de la fonction liretab entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier appel de la fonction ecriretab1(Liste, 0, 3) 3 0 debut entier fin entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier ecriretab1 entier i 3 0 debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier ecriretab1 entier i i  debut debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n ecriretab1 entier i i  debut TANT QUE (i < fin) FAIRE ÉCRIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier ecriretab1 entier i i  debut TANT QUE (i < fin) FAIRE ÉCRIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier ecriretab1 entier i i  debut TANT QUE (i < fin) FAIRE ÉCRIRE T[i] i  i debut entier fin i entier 18

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier ecriretab1 entier i i  debut TANT QUE (i < fin) FAIRE ÉCRIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier ecriretab1 entier i i  debut TANT QUE (i < fin) FAIRE ÉCRIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier ecriretab1 entier i i  debut TANT QUE (i < fin) FAIRE ÉCRIRE T[i] i  i debut entier fin i entier 18 93

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier ecriretab1 entier i i  debut TANT QUE (i < fin) FAIRE ÉCRIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier ecriretab1 entier i i  debut TANT QUE (i < fin) FAIRE ÉCRIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier ecriretab1 entier i i  debut TANT QUE (i < fin) FAIRE ÉCRIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier ecriretab1 entier i i  debut TANT QUE (i < fin) FAIRE ÉCRIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier ecriretab1 entier i i  debut TANT QUE (i < fin) FAIRE ÉCRIRE T[i] i  i debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : Liste[499] Liste[2] Liste[1] Liste[0] entier n entier retour de la fonction ecriretab1 entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier appel de la fonction ecriretab2(Liste, 0, 3) 3 0 debut entier fin entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier ecriretab2 entier i 3 0 debut entier fin i entier

Étude de cas 1 T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier ecriretab2 entier i i  fin debut entier fin i entier Pas-à-pas Entrée :

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier ecriretab2 entier i i  fin TANT QUE (i >debut) FAIRE i  i - 1 ÉCRIRE T[i] debut entier fin i entier

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier debut entier fin i entier ecriretab2 entier i i  fin TANT QUE (i >debut) FAIRE i  i - 1 ÉCRIRE T[i]

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier debut entier fin i entier 107 ecriretab2 entier i i  fin TANT QUE (i >debut) FAIRE i  i - 1 ÉCRIRE T[i]

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier debut entier fin i entier ecriretab2 entier i i  fin TANT QUE (i > debut) FAIRE i  i - 1 ÉCRIRE T[i]

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier debut entier fin i entier ecriretab2 entier i i  fin TANT QUE (i > debut) FAIRE i  i - 1 ÉCRIRE T[i]

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier debut entier fin i entier ecriretab2 entier i i  fin TANT QUE (i > debut) FAIRE i  i - 1 ÉCRIRE T[i]

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier debut entier fin i entier ecriretab2 entier i i  fin TANT QUE (i > debut) FAIRE i  i - 1 ÉCRIRE T[i]

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier debut entier fin i entier ecriretab2 entier i i  fin TANT QUE (i > debut) FAIRE i  i - 1 ÉCRIRE T[i]

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier debut entier fin i entier ecriretab2 entier i i  fin TANT QUE (i > debut) FAIRE i  i - 1 ÉCRIRE T[i]

Étude de cas 1 Pas-à-pas Entrée : T[499]  Liste[499] T[2]  Liste[2] T[1]  Liste[1] T[0]  Liste[0] entier n entier debut entier fin i entier ecriretab2 entier i i  fin TANT QUE (i > debut) FAIRE i  i - 1 ÉCRIRE T[i]

Étude de cas 1 Pas-à-pas Entrée : Liste[499] Liste[2] Liste[1] Liste[0] entier n entier retour de la fonction ecriretab2 fin du programme entier

Défi 1.Résoudre ce problème sans utiliser de tableau. 2.Afficher la liste à l’envers d’abord puis à l’endroit

Étude de cas 2 Description du problème : Une liste de notes a été produite pour une classe. Afficher cette liste et afficher la plus petite note, la plus grande et la moyenne. Finalement, afficher la liste des notes sous la moyenne. Spécification de l’entrée : Un entier n suivi d’une liste de n notes. Sortie : Une liste de n entiers suivie de deux entiers puis d’un réel et finalement une liste de moins de n entiers.

Étude de cas 2 Fonction principale variables tableau d’entiers Notes de taille 300 entier n réel notemoyenne instructions LIRE n SI ( n  0 OU n > 300 ) ÉCRIRE « erreur dans les données » SINON liretab(Notes, 0, n) ecriretab1(Notes, 0, n) ÉCRIRE « le maximum est » maximum(Notes, n) ÉCRIRE « le minimum est » minimum(Notes, n) notemoyenne  moyenne(Notes, n) ÉCRIRE « la moyenne est » notemoyenne ecrire_sous_moyenne(Notes, n, notemoyenne)

Étude de cas 2 où les prototypes des fonctions utilisées sont: liretab(tableau d’entiers, entier, entier) écriretab1(tableau d’entiers, entier, entier) maximum(tableau d’entiers, entier) retourne un entier minimum(tableau d’entiers, entier) retourne un entier moyenne(tableau d’entiers, entier) retourne un réel ecrire_sous_moyenne(tableau d’entiers, entier, réel)

Étude de cas 2 Fonction maximum prototype maximum (tableau d’entiers T, entier n) retourne un entier variables entier max, i instructions max  T[0] POUR i  1 À (n-1) AVEC PAS DE 1, FAIRE SI max < T[i] ALORS max  T[i] But : La variable max contient le maximum de T[0]...T[n-1] RETOURNER max Comment faire avec un TANT QUE ?

Étude de cas 2 Fonction moyenne prototype moyenne (tableau d’entiers T, entier n) retourne un réel variables entier somme, i instructions somme  0 POUR i  0 À (n-1) AVEC PAS DE 1, FAIRE somme  somme + T[i] But : La variable somme contient la somme de T[0] à T[n-1] RETOURNER somme / n Comment faire avec un TANT QUE ?

Étude de cas 2 Fonction ecrire_sous_moyenne prototype ecrire_sous_moyenne (tableau d’entiers T, entier n, réel m) variables entier i instructions somme  0 POUR i  0 À (n-1) AVEC PAS DE 1, FAIRE SI T[i] < m ALORS ÉCRIRE T[i] i  i + 1 But : Toutes les notes sous la moyenne parmi T[0]...T[n-1] ont été affichées Comment faire avec un TANT QUE ?

Comment le faire en C++ Déclarer le tableau de réels F de taille 1000 double F[1000] ; Déclarer le tableau d’entiers TAB de taille 5 int TAB[5] ; Déclarer le tableau d’entiers Liste de taille500 int Liste[500] ;

Comment le faire en C++ Exemple : la suite de Fibonacci int T[10] ; n = 10 ; T[0] = 0 ; T[1] = 1 ; for ( i = 2; i < n; i = i + 1 ) T[i] = T[i-1] + T[i-2] ; T:T:

Les tableaux Exemple : tableau d’entiers TAB de taille TAB[4] TAB[3] TAB[2] TAB[1] TAB[0] entier TAB : Deux façons de se représenter un tableau

Opérations courantes Lire une liste de valeurs à mettre dans un tableau Initialiser un tableau Copier un tableau dans un autre Afficher le contenu d’un tableau Chercher un élément dans un tableau Chercher le plus grand élément dans un tableau Chercher le plus petit élément dans un tableau Ajouter un élément dans un tableau Enlever un élément dans un tableau Changer l’ordre des éléments dans un tableau Trier un tableau Etc.

Lire une liste de valeurs 3 méthodes: - longueur de la liste au début - valeur spéciale à la fin - lire jusqu’à la fin du fichier Exemple : (On suppose que MAX est une constante) tableau d’entiers TAB de taille MAX entier n n  0 TANT QUE ((n<MAX) ET (LIRE(TAB[n])  FDF)) FAIRE n  n + 1 SI (n = MAX) ALORS ÉCRIRE « Liste trop longue »

Initialiser un tableau Trois exemples : POUR i  0 À (MAX-1), PAS de 1 TAB1[i]  0 POUR i  0 À (MAX-1), PAS de 1 TAB2[i]  2*i POUR i  0 À (MAX-1), PAS de 1 TAB3[i]  TAB2[i] Et avec des TANT QUE ? TAB1 : TAB2 : TAB3 :

Copier un tableau dans un autre POUR i  0 À (MAX-1), PAS de 1 TAB3[i]  TAB2[i] Et avec des TANT QUE ? TAB2 : TAB3 :

Afficher le contenu d’un tableau POUR i  0 À (MAX-1), PAS de 1 ÉCRIRE TAB[i] ou i  0 TANT QUE i < MAX FAIRE ÉCRIRE TAB[i] i  i + 1

Chercher un élément Fonction chercher prototype chercher(tableau de réels TAB, entier n, réel x) retourne un entier Cette fonction cherche la première occurrence de l’élément x parmi les n premiers éléments du tableau TAB et retourne la position de cet élément. Si x n’est pas trouvé alors la fonction retourne -1. variables entier i {indique la position dans le tableau} instructions POUR i  0 À (n-1), PAS de 1 SI (TAB[i] = x) ALORS RETOURNER i RETOURNER -1 TANT QUE ?

Ajouter un élément x à la fin On suppose que MAX est la taille du tableau TAB et n est le nombre d’éléments dans TAB. SI (n < MAX) ALORS TAB[n]  x n  n + 1 SINON ÉCRIRE « impossible d’ajouter un élément »

Ajouter un élément x au début On suppose que MAX est la taille du tableau TAB et n est le nombre d’éléments dans TAB. On veut ajouter x au début du tableau. SI (n < MAX) ALORS Déplacer tous les éléments d’une case vers la fin. Insérer x au début du tableau. Incrémenter n. SINON ÉCRIRE « impossible d’ajouter un élément »

Ajouter un élément x au début On suppose que MAX est la taille du tableau TAB et n est le nombre d’éléments dans TAB. On veut ajouter x au début du tableau. SI (n < MAX) ALORS POUR i  n À 1, PAS de -1 TAB[i]  TAB[i-1] Insérer x au début du tableau. Incrémenter n. SINON ÉCRIRE « impossible d’ajouter un élément »

Ajouter un élément au début On suppose que MAX est la taille du tableau TAB et n est le nombre d’éléments dans TAB. On veut ajouter x au début du tableau. SI (n < MAX) ALORS POUR i  n À 1, PAS de -1 TAB[i]  TAB[i-1] Insérer x au début du tableau. Incrémenter n SINON ÉCRIRE « impossible d’ajouter un élément » 024 TAB : MAX=5 n=3

Ajouter un élément au début On suppose que MAX est la taille du tableau TAB et n est le nombre d’éléments dans TAB. On veut ajouter x au début du tableau. SI (n < MAX) ALORS POUR i  n À 1, PAS de -1 TAB[i]  TAB[i-1] TAB[0]  x n  n + 1 SINON ÉCRIRE « impossible d’ajouter un élément » 024 TAB : x MAX=5 n=4 0

Enlever un élément à la fin SI (n > 0) ALORS n  n - 1 SINON ÉCRIRE « impossible d’enlever un élément »

Enlever un élément au début SI (n > 0) ALORS Déplacer les éléments du tableaux vers le début Décrémenter n SINON ÉCRIRE « impossible d’enlever un élément »

Enlever un élément au début SI (n > 0) ALORS POUR i  1 À (n-1), PAS de 1 TAB[i-1]  TAB[i] Décrémenter n SINON ÉCRIRE « impossible d’enlever un élément »

Enlever un élément au début SI (n > 0) ALORS POUR i  1 À (n-1), PAS de 1 TAB[i-1]  TAB[i] Décrémenter n SINON ÉCRIRE « impossible d’enlever un élément » 0246 TAB : MAX=5 n=4

Enlever un élément au début SI (n > 0) ALORS POUR i  1 À (n-1), PAS de 1 TAB[i-1]  TAB[i] n  n - 1 SINON ÉCRIRE « impossible d’enlever un élément » 246 TAB : MAX=5 n=3 6

Enlever un élément Dans certaines situations, il n’est pas nécessaire de déplacer les éléments pour en enlever un. On remplace alors l’élément à enlever par une valeur spéciale indiquant qu’il n’y a pas d’élément à cet emplacement. C’est alors comme s’il y avait des trous dans le tableau. 246 TAB : La valeur -1 indique qu’il n’y a pas de valeur à cet emplacement.

Changer l’ordre des éléments L’opération de base ici consiste à échanger le contenu de deux cases (disons i et j) dans un tableau: x  TAB[i] TAB[i]  TAB[j] TAB[j]  x TAB : MAX=5 n= TAB : i=1 et j=4

Changer l’ordre des éléments Observation Pour pouvoir changer l’ordre d’un tableau il suffit de savoir échanger deux éléments TAB : MAX=5 n= TAB : échanger TAB[0] et TAB[3]: TAB : échanger TAB[1] et TAB[2]: TAB : échanger TAB[3] et TAB[4]: TAB : 01234

Trier un tableau Il existe une très grande variété de techniques permettant de trier un tableau en ordre croissant. En voici une. Trouver le plus petit élément L’échanger avec TAB[0] Trouver le second plus petit élément L’échanger avec TAB[1] Trouver le troisième plus petit élément L’échanger avec TAB[2] ETC.

32140 TAB : On cherche le plus petit élément On échange TAB[0] et TAB[4] On échange TAB[1] et TAB[2] 243 On échange TAB[2] et TAB[2] On cherche le plus petit élément On échange TAB[3] et TAB[4] Trier un tableau

/* Ce programme lit un maximum de MAX entiers, les trie et les affiche */ int main() { int tab[MAX] ; int n ; n = lire(tab,MAX) ; trier(tab,n) ; afficher(tab,n) ; return 0 ; }

Trier un tableau /* Lit en entrée un maximum de M entiers et les place dans le tableau T */ int lire (int T[], int M) { int i = 0 ; while ( i > T[i] ) i = i + 1 ; return i ; } /* Affiche le contenu des n premières cases du tableau T */ void afficher (int T[], int n) { int i ; for ( i = 0; i < n; i = i + 1 ) std::cout << T[i] << std::endl ; }

Trier un tableau /* Trie les n premiers éléments du tableau T */ void trier ( int T[], int n) { int i, pmin ; for ( i = 0; i < n - 1; i = i + 1 ) { pmin = minimum( T, i, n ) ; echanger ( T[i], T[pmin] ); }

Trier un tableau /* Retourne la position du plus petit élément du tableau T entre les positions i et n-1 */ int minimum ( int T[], int i, int n ) { int k, min, pos ; min = T[i] ; pos = i ; for ( k = i + 1; k < n; k = k + 1 ) if ( T[k] < min) { min = T[k] ; pos = k ; } return pos ; }

Trier un tableau /* Échange le contenu des positions a et b du tableau T */ void echanger ( int & a, int & b ) { int tmp ; tmp = a ; a = b ; b = tmp ; }

Étude de cas 3 Description du problème : Calculer le produit de deux vecteurs de longueur n. Spécification de l’entrée : Un entier n suivi d’une liste de n nombres réels définissant le premier vecteur puis, une deuxième liste de n nombres réels définissant le second vecteur. Sortie: Une liste de n nombres réels.

Étude de cas 3 Rappel Le produit scalaire du vecteur et du vecteurest un nombre entier AB défini par l’équation suivante :

Étude de cas 3 Fonction principale entier n tableau de réels A de taille n {Premier vecteur} tableau de réels B de taille n {Second vecteur} LIRE n liretab(A, 0, n) liretab(B, 0, n) ÉCRIRE prodvecteur(A, B, n) où prodvecteur satisfait le prototype: prodvecteur(tableau de réels, tableau de réels, entier) retourne un réel

Étude de cas 3 prodvecteur(tableau de réels X, tableau de réels Y, entier n) retourne un réel entier i réel somme somme  0 POUR i  0 À (n-1), PAS de 1 somme  somme + X[i]*Y[i] But : somme = X[0]*Y[0] +  + X[n-1]*Y[n-1] RETOURNER somme