Insertion d'un élément dans un tableau
Énoncé
Écrire une marche à suivre qui permet d'insérer un entier A dans un tableau T
à N éléments à la position P (N, T, P et A sont des données).

I) Préanalyse :
Données : 
..............- Le nombre d'éléments de T  (N=6);
..............- Un tableau T à N éléments de types entiers ;
  17 33 50 10 12 15 ? ? ? ?
1
2
P= 3
4
5
N=6
7
8
9
NMAX=10
 
 .............- La position d'insertion P (P=3); 
..............- La valeur à insérer A (A=99).

Résultat :

T 17 33 99 50 10 12 15 ? ? ?
1
2
P= 3
4
5
6
N=7
8
9
NMAX=10

Étape 1 : Décaler, d'une case à droite, les éléments de T à partir de la position N à la position d'insertion P :
Pas 1:...............T[N+1]ß T[N]. ............(T[7]ß T[6])

  17 33 50 10 12 15 15 ? ? ?
1
2
P= 3
4
5
N=6
7
8
9
NMAX=10

Pas 2:                T[N] ß T[N-1]           (T[6] ß T[5])

T 17 33 50 10 12 12 15 ? ? ?
1
2
P= 3
4
5
N=6
7
8
9
NMAX=10

Pas 3:                 T[N-1]ß T[N-2]       (T[5]ß T[4])

T 17 33 50 10 10 12 15      
1
1
2
P= 3
4
5
N=6
7
8
9
NMAX=10

etc        Jusqu'à         T[P+1]ß T[P]   (T[4]ß T[3])

T 17 33 50 50 10 12 15 ? ? ?
1
2
P= 3
4
5
N=6
7
8
9
NMAX=10


Étape 2 : insérer la valeur de A dans T à la position P :
 T[P]ß A               (T[3]ß 99).........

T 17 33 99 50 10 12 15 ? ? ?
1
2
P= 3
4
5
N=6
7
8
9
NMAX=10
 
Le nombre d'éléments devient ( N ß N+1)    c'est à dire    N=6+1



...................................................................................    .Les noms des modules (sous-programmes)
Saisir (Lire) le nombre d'éléments de T ....................................................  Proc Lecture(N)
Remplir le tableau T par N éléments ........................................................  Proc Remplir(N,T)
Lire la valeur à insérer A .......................................................................... Proc Saisie(A)
Lire la position d'insertion de l'entier A ..................................................... Proc Position(P)
Décaler à droite les valeurs du tableau T de position N à la position P.......  Proc Decaler(P,N,T)
Incrémenter une fois la valeur de N..........................................................  FN Incrementer(N)
Insérer la valeur de A dans le tableau T à la position P.............................. Proc Inserer(P,A,,T)
Afficher le tableau T après insertion.......................................................... Proc Affiche(N,T)
	
II) Analyses & Algorithmes :
1) Analyse du programme principal

Nom : Inserer_element
S.
LDE
O.U.

8

7

1

6

3

4

5

2

9

Résultats : Proc Affiche ( N , T)

N ß FN Incrementer ( N )

Proc Lecture( N )

Proc Inserer ( P , A ,Td )

Proc Position ( N , P )

Proc Saisie ( A )

Proc Decaler ( P , N ,T )

Proc Remplir ( N , T )

Fin Inserer_element

P
A
N
T

Affiche, Saisie

Decaler, Remplir

Incrementer

Lecture

Inserer

Position

 
Tableau de déclaration des objets :
O.U.
Nature / Type
Rôle
P
variable / Entier
 		La position d'insertion
A
variable / Entier
 		La valeur à insérer
N
variable / Entier
 		Le nombre d'éléments dans T avant puis après insertion 
T
variable / Tab
 		Tableau des valeurs à l'état initial, après le
décalage des éléments puis après insertion
Lecture
Procédure
 		Lecture de N
Remplir
Procédure
 		Remplir le tableau T par des valeurs
Position
Procédure
 		Lecture de la position d'insertion
Saisie
Procédure
 		Lecture de la valeur à insérer
Decaler
Procédure
 		Décaler les éléments du tableau d'une case
à droite à partir de la position p
Incrementer
Fonction / Entier
 		Incrémenter une fois la valeur de N (N+1)
Inserer
Procédure
 		Insérer la valeur de A à la position P
Affiche
Procédure
 		Afficher les valeurs du tableau après insertion

Nouveau Type        Tab = Tableau de NMax entiers      NMax est une constante égale à 10

 
Algorithme du programme principal :
0-
1-
2-
3-
4-
5-
6-
7-
8-
9-		 Début Inserer_element
Proc Lecture( N )
Proc Remplir ( N , T )
Proc Position ( N , P )
Proc Saisie ( A )
Proc Decaler ( P , N ,T )
Proc Inserer ( P , A ,T )
N ß FN Incrementer ( N )
Proc Affiche ( N , T )
Fin Inserer_element		 
2) Analyse de la procédure Lecture

DEF PROC Lecture (Var N : Entier)
S.
LDE
O.U.
1


2
 		Résultat : Répéter
                       Lire(N)
               Jusqu'à N dans [1 .. Nmax ]
Fin Lecture		 
Algorithme de la procédure Lecture 
0-
1-


2-		 DEF PROC Lecture (Var N : Entier)
Répeter
         Lire( N )
Jusqu'à N dans [1 .. Nmax]
Fin Lecture		 
3) Analyse de la procédure Remplir

DEF PROC Remplir ( N : Entier ; Var T : Tab )
S.
LDE
O.U.
1
2
 		Résultat : Pour I de 1 à N Faire
                          Lire(T[I])
               Fin Pour
Fin Remplir
I
 
Tableau de déclaration des objets :
O.U.
Nature / Type
Rôle
I
Variable / Entier
 		Compteur 
Algorithme de la procédure Remplir :
0-
1-


2-

 DEF PROC Remplir ( N : Entier ; Var T : Tab )
Pour I de 1 à N Faire
                 Lire( T[I] )
Fin Pour
Fin Remplir		 
4) Analyse de la procédure Position

DEF PROC Position ( N : Entier ; Var P : Entier )
S.
LDE
O.U.
1


2
 		Résultat : Répeter
                       Lire(P)
               Jusqu'à P dans [ 1 .. N ]
Fin Position		 
Algorithme de la procédure Position :
0-
1-


2-

 DEF PROC Position ( N : Entier ; Var P : Entier )
Répeter
             Lire( P )
Jusqu'à P dans [1 .. N]
Fin Position		 
5) Analyse de la procédure Saisie

DEF PROC Saisie ( Var A : Entier )
S.
LDE
O.U.
1
2
 		Résultat : Lire(A)
Fin Saisie		 
Algorithme de la procédure Saisie :
0-
1-
2-		 DEF PROC Saisie ( Var A : Entier )
Lire( A)
Fin Saisie		 
6) Analyse de la procédure Decaler :

DEF PROC Decaler ( P , N : Entier  ;  Var T : TAB )
S.
LDE
O.U.
1

2
 		Résultat : Pour I de (N+1) à (P+1) Faire
                             T[I] ß   T[I-1]
               Fin Pour
Fin Decaler


I

 
Tableau de déclaration des objets :
O.U.
Nature / Type
Rôle
I
Variable / Entier
 		Compteur 
Algorithme de la procédure Decaler :
0-
1-


2-

 DEF PROC Decaler ( P , N : Entier ; Var T : TAB )
Pour I de (N+1) à (P+1) Faire
          T[I] ß  T[I-1]
Fin Pour
Fin Decaler		 
7) Analyse de la procédure Inserer :

DEF PROC Inserer ( P , A : Entier ; Var T : Tab)

S.
LDE
O.U.
1
2
 		Résultat :  T[P] ß  A
Fin Position		 
Algorithme de la procédure Inserer :
0-
1-
2-		 DEF PROC Inserer ( P , A , N : Entier ; Var T : Tab)
T[P] ß  A
Fin Inserer		 
8) Analyse de la Fonction Incrementer :

DEF FN Incrementer ( N : Entier ) : Entier
S.
LDE
O.U.
1
2
 		Résultat : Incrementer ß  N + 1
Fin Incrementer 
Algorithme de la Fonction Incrementer :
0-
1-
2-		 DEF FN Incrementer ( N : Entier ) : Entier
Incrementer ß  N + 1
Fin Incrementer		 
9) Analyse de la procédure Affiche :

DEF PROC Affiche ( N : Entier ; T : Tab )
S.
LDE
O.U.

1


2

 		Résultat :Pour I de 1 à N Faire
                   Ecrire ( T[I] )
              Fin Pour
Fin Affiche

 

I

 
Tableau de déclaration des objets :
O.U.
Nature / Type
Rôle
I
Variable / Entier
 		Compteur 
Algorithme de la procédure Affiche :
0-
1-


2-

 DEF PROC Affiche ( N : Entier ; T : Tab )
Pour I de 1 à N faire
         Ecrire ( T[I] )
Fin Pour
Fin Affiche

III) Traduction en Turbo Pascal :

Program Inserer_element ;

Const NMax = 10 ;

Type Tab = ARRAY [1..Nmax] Of Integer ;

Var T : Tab ;

       N,P,A : Integer ;
{----------------------------------------------------}

PROCEDURE Lecture ( Var N : Integer ) ;

Begin

         Repeat
              Write('N=');

              Readln ( N ) ;

         Until N in [ 1 .. Nmax ] ;

End ;
{----------------------------------------------------}

PROCEDURE Remplir ( N : Integer ; Var T : Tab ) ;

Var I : Integer ;

Begin

         For I : = 1 To N Do
         Begin
                Write('T[',I,']=');

                Readln ( T[I] ) ;
         End;

End ;
{----------------------------------------------------}

PROCEDURE Position ( N : Integer ; Var P : Integer ) ;

Begin

       Repeat
                Write('P=');

                Readln ( P ) ;

        Until N in [ 1 .. N] ;

End ;
{----------------------------------------------------}

PROCEDURE Saisie ( Var A : Integer ) ;

Begin

        Write('A=');            
        Readln ( A ) ;

End ;
{----------------------------------------------------}

PROCEDURE Decaler ( P , N : Integer ; Var T : TAB ) ;

Var I : Integer ;

Begin

      For I : = (N+1) To (P+1) Do 
          T[I] : = T[I-1] ;
End;

{----------------------------------------------------}

PROCEDURE Inserer ( P , A : Integer ; Var T : Tab) ;

Begin

        T[P] : = A;

End ;
{----------------------------------------------------}

FUNCTION Incrementer ( N : Integer ) : Integer ;

Begin
        Incrementer : = N + 1 ;

End ;
{----------------------------------------------------}

PROCEDURE Affiche ( N : Integer ; T : Tab ) ;

Var I : Integer ;

Begin

        For I : = 1 To N Do

            Writeln ( 'T[',I,']=', T[I] ) ;

End; 
{===================================}

Begin

    Lecture( N );

    Remplir ( N , T );

    Position ( N , P );

    Saisie ( A );

    Decaler ( P , N , T );

    Inserer ( P , A , T );

    N := Incrementer ( N );

    Affiche ( N , T );

End.
 {===================================}

 
Page d'index Série Les tableaux Haut