cinquième place - sixième place.

X[ 3 ] : =X [ 4 ];

X[ 4 ] : =X [ 5 ];

X[ 5 ] : =X [ 6 ];

Ainsi, tous les éléments du troisième au cinquième doivent être déplacés d'un vers la gauche - à la place du i-ème élément, vous devez écrire (i+1)-ème. Le schéma fonctionnel de l’algorithme est présenté sur la Fig. 5.25.

Riz. 5.25.

Riz. 5.26.

Riz. 5.27.

Maintenant, regardons plus tâche commune: Vous devez supprimer le mième élément d’un tableau X composé de n éléments. Pour ce faire, il suffit d'écrire le (m+1)ème élément à la place de l'élément de numéro m, le (m+2)ème élément - à la place du (m+1)ème élément, etc. , le nième élément - à la place (n–1)ème. Le processus de suppression d'un élément d'un tableau est illustré à la Fig. 5.26.

L'algorithme pour supprimer un élément de numéro m d'un tableau X de dimension n est illustré à la Fig. 5.27.

Après avoir retiré l'élément 4 Et en fait, décaler une partie du tableau d'un élément vers la gaucheà partir du tableau, le nombre d'éléments dans le tableau changera (diminué de un) et l'index de certains éléments changera. Si un élément est supprimé, alors le suivant prend sa place, et il n'est pas nécessaire de s'y déplacer (en augmentant l'index de un). Élément suivant lui-même s'est déplacé vers la gauche après le retrait.

Si vous traitez un tableau dans lequel certains éléments sont supprimés, après avoir supprimé un élément, vous n'avez pas besoin de passer au suivant (cela réduit le nombre d'éléments). À titre d’exemple, considérons le problème suivant.

TÂCHE 5.1. Supprimez les éléments négatifs d'un tableau.

L'algorithme pour résoudre le problème est assez simple : on parcourt tous les éléments du tableau, si l'élément est négatif, alors on le supprime en décalant tous les éléments suivants d'un vers la gauche. La seule chose à retenir est qu'après avoir supprimé un élément, vous n'avez pas besoin de passer au suivant pour un traitement ultérieur, il se déplace lui-même à la place de l'élément actuel. Le schéma fonctionnel pour résoudre le problème 5.1 est présenté sur la Fig. 5.28.

Ci-dessous le texte du programme avec commentaires.

programme support_array ; var i, n, j : octet ; X : tableau [ 1.. 100 ] de réel ;<=n) do {Если очередной элемент массива X[i] отрицателен, то} if x [ i ]<0 then begin {удаляем элемент массива с номером i.} for j:= i to n_1 do x [ j ] : = x [ j + 1 ]; {Уменьшаем размер массива.} {Не надо переходить к следующему элементу массива.} n:=n -1; end else {Если элемент не удалялся, то переходим к следующему элементу массива.} i:= i +1; writeln (’Изменённый массив ’); for i:=1 to n do {Вывод преобразованного массива.} write (X[ i ] : 5: 2, ’ ’); writeln; end.

start writeln('entrez la taille du tableau'); readln(n); (Entrée de tableau.) pour i:=1 à n, commencez l'écriture ('X[ ', i, ' ]= '); readln(X[i]); fin; writeln('tableau X'); pour i:=1 à n écrivez (x [ i ] : 5 : 2, ’ ’); écrire; je : = 1 ; pendant que (je

Riz. 5.28.

Les résultats du programme sont présentés dans la Fig. 5.29.

Riz. 5.29.

5.9 Insertion d'un élément dans un tableau

Considérons une tâche simple : insérez le nombre b dans le tableau X(10) , entre le troisième et le quatrième élément.

Pour résoudre ce problème, vous devez décaler tous les éléments du tableau, en commençant par le quatrième, vers la droite d'un élément. Ensuite, vous devrez écrire b (X:=b;) dans le quatrième élément du tableau. Mais pour ne pas perdre la valeur voisine, il faut d'abord décaler le dixième élément vers la droite, puis le neuvième, le huitième, etc. jusqu'au quatrième. Le schéma fonctionnel de l'algorithme d'insertion est présenté sur la Fig. 17h30.

Riz. 17h30.

Dans le cas général, le schéma fonctionnel de l'insertion du nombre b dans le tableau X(N) entre les éléments numérotés m et m+1 est illustré à la Fig. 5.31.

Riz. 5.31. Vous trouverez ci-dessous un fragment de programme qui implémente cet algorithme 5 .

Lors de la déclaration d'un tableau, vous devez fournir une taille suffisante pour insérer un élément.

var i, n,m : octet ;

X : tableau [ 1.. 100 ] de réel ; b : réel ; commencer l'écriture ('N= '); readln(n); pour i:=1 à n, commencez à écrire (’X[ ’, i, ’ ]= ’); readln(X[je]); fin; writeln('Tableau X'); pour i:=1 à n écrivez (x [ i ] : 5 : 2, ’ ’); écrire; writeln('m='); readln(m); writeln('b='); readln(b); pour i:=n jusqu'à m+1 faire x [ i +1]:=x [ i ]; x :=b; n:=n+1; writeln('Tableau modifié'); pour i:=1 à n écrivez (X[ i ] : 5 : 2, ’ ’); écrire; fin.

5.10 Utiliser des routines pour travailler avec des tableaux Voyons comment transmettre des tableaux à un sous-programme. Comme vous le savez (voir chapitre 4), pour déclarer des variables dans la liste des paramètres formels d'un sous-programme, vous devez spécifier leurs noms et types. Cependant, le type de tout paramètre de la liste ne peut être qu'un type standard ou déclaré précédemment. Par conséquent, pour passer un tableau à un sous-programme, vous devez d’abord décrire son type 6 Type de données tableau, déclaration de tableau voir section 2.4.9. L'utilisation de tableaux est décrite en détail dans ce chapitre. puis déclarez la procédure : type_tableau =

tableau

[liste_index]

de

taper;

Il est clair que passer une chaîne du formulaire à un sous-programme

nom_variable : chaîne[longueur_chaîne] ;

qui est en fait un tableau de 7 Type de données "string", déclaration de chaîne voir clause 2.4.9, doit être effectué de la même manière :

type_ligne = chaîne[longueur_chaîne] ;

tableau

nom_procédure (nom_chaîne : type_chaîne);

de

tapez string_5=chaîne [ 5 ]; stroka_10=chaîne [ 1 0 ]; fonction fun (S t r : stroka_5) : stroka_10;

Les tableaux peuvent être transmis à un sous-programme en utilisant le concept de tableau ouvert. Le tableau ouvert est le tableau 8 Le type de données "array", la déclaration du tableau, l'accès au tableau, voir section 2.4.9., dont la description indique le type d'éléments qui le composent, mais ne définit pas les limites de modification des indices :

nom_tableau_public : tableau de tableau de... type_tableau =

de

var array_1 : tableau de réels ; array_2 : tableau de tableaux de caractères ; array_3 : tableau de tableau de tableau d'octets ;

Allocation de mémoire et spécification des limites de l'index

Matériel théorique

Travail indépendant

Lors de la déclaration d'un tableau, nous définissons sa dimension maximale, qui ne pourra plus être modifiée ultérieurement. Cependant, à l'aide d'une variable auxiliaire, vous pouvez contrôler le nombre actuel d'éléments, qui ne peut pas être supérieur au maximum.

Commentaire. L'espace de noms System.Collection implémente la collection ArrayList - un tableau qui change dynamiquement sa taille. Nous y reviendrons plus tard.

Exemple. Regardons un fragment de programme :

int a=nouveau int ;

pour (int je=0; je<5;i++) a[i]:=i*i;

Dans ce cas, le tableau peut être représenté comme suit :

n=5
UN

Puisque lors de la description un tableau de 10 éléments a été défini, et que seuls les 5 premiers ont été remplis, les éléments restants seront remplis de zéros.

Que signifie supprimer l'élément numéro 3 d'un tableau unidimensionnel ? La suppression devrait entraîner la « destruction » physique de l’élément numéro 3 du tableau et le nombre total d’éléments devrait être réduit. Dans cette compréhension de la suppression d'éléments, le tableau résultant devrait ressembler à ceci

En général, si nous voulons supprimer un élément du tableau de numéro k (il y a n éléments dans le tableau et le dernier élément a l'indice n-1), alors nous devons décaler les éléments, en commençant par k+1, d'une position À gauche. Ceux. à la kième place mettre le k+1er élément, à la place k+1 - k+2ème élément, ..., à la place n-2 - n-1er élément. Diminuez ensuite la valeur de n de 1. Dans ce cas, la dimension du tableau ne changera pas, seul le nombre actuel d'éléments changera, et nous aurons l'impression que l'élément numéro k a été supprimé. Regardons cet algorithme à l'aide d'un exemple :

Espace de noms ConsoleApplication

entrée int statique()

int a=nouveau int[n];

pour (int je = 0; je< n; ++i)

Console.Write("a[(0)]= ", i);

pour (int je = 0; je< n; ++i) Console.Write("{0} ", a[i]);

Console.WriteLine();

static void DeleteArray (int a, ref int n, int m)

pour (int je = m; je< n-1; ++i)

vide statique Main()

int monArray=Entrée();

int n=myArray.Length;

Imprimer(monArray, n);

Console.WriteLine("Entrez le numéro de l'élément à supprimer :");

SupprimerArray(monArray, réf n,m);

Imprimer(monArray, n);

Exercice. Pensez aux exceptions qui pourraient se produire dans un programme donné et ajoutez-y une gestion appropriée des exceptions.

Considérons maintenant l'opération de suppression dans un tableau à deux dimensions. La dimension d'un tableau à deux dimensions est également fixée au stade de la déclaration du tableau. Cependant, si nécessaire, vous pouvez « simuler » la suppression d'une ligne entière dans un tableau en décalant toutes les lignes, en commençant par la kième, vers le haut d'une unité. Dans ce cas, la taille du tableau ne changera pas et le nombre actuel de lignes sera réduit d'une. À titre d'exemple, supprimons le numéro de ligne k d'un tableau à deux dimensions.

Espace de noms ConsoleApplication

Console.WriteLine("entrez la dimension du tableau");

Console.Write("n = ");

n=int.Parse(Console.ReadLine());

Console.Write("m = ");

m=int.Parse(Console.ReadLine());

int [,]a=nouveau int;

pour (int je = 0; je< n; ++i)

pour (int j = 0; j< m; ++j)

pour (int je = 0; je< n; ++i,Console.WriteLine())

pour (int j = 0; j< m; ++j)

static void DeleteArray(int[,] a, ref int n, int m, int k)

pour (int je = k; je< n-1; ++i)

pour (int j = 0; j< m; ++j)

une = une;

vide statique Main()

Console.WriteLine("Tableau source :");

Imprimer(monArray, n, m);

SupprimerArray(monArray, réf n, m, k);

Console.WriteLine("Tableau modifié :");

Imprimer(monArray, n, m);

Quêtes.

1. Modifiez le programme pour supprimer la kème colonne dans un tableau à deux dimensions.

Considérons une modification du programme précédent, pour le cas où un tableau échelonné est utilisé.

Espace de noms ConsoleApplication

Console.WriteLine("entrez la dimension du tableau");

Console.Write("n = ");

n=int.Parse(Console.ReadLine());

Console.Write("m = ");

m=int.Parse(Console.ReadLine());

int a=nouveau int[n];

pour (int je = 0; je< n; ++i)

a[i]=nouveau int[m];

pour (int j = 0; j< m; ++j)

Console.Write("a[(0),(1)]= ", i, j);

pour (int je = 0; je< n; ++i,Console.WriteLine())

pour (int j = 0; j< m; ++j)

Console.Write("(0,5) ", a[i] [j]);

static void DeleteArray (int a, ref int n, int k)

pour (int je = k; je< n-1; ++i)//производим сдвиг ссылок

vide statique Main()

Console.WriteLine("Tableau source :");

Imprimer(monArray, n, m);

Console.WriteLine("Entrez le numéro de ligne à supprimer :");

int k=int.Parse(Console.ReadLine());

SupprimerArray(monArray, réf n, k);

Console.WriteLine("Tableau modifié :");

Imprimer(monArray, n, m);

Revenons au tableau défini dans le tout premier exemple. Et maintenant, réfléchissons à ce que signifie ajouter un élément à un tableau unidimensionnel à la position k ? Dans ce cas, tous les éléments à partir du kième doivent être décalés d'une position vers la droite. Cependant, le changement doit commencer par la fin, c'est-à-dire dans un premier temps, placez le n-1er élément à la n-ème place, puis placez le n-2ème élément à la n-1ère place, ... enfin, insérez le k-ème élément à la k+1 place. Ainsi, une copie du kème élément sera à la k+1ère place et un nouvel élément pourra être placé à la kème place. Ensuite, vous devez augmenter le nombre actuel d'éléments de 1.

Considérez le tableau de l'exemple 1 et définissez k sur 3. Dans ce cas, le tableau ressemblera à ceci :

k=3
UN

Une nouvelle valeur peut maintenant être placée à la position numéro 3. Et le nombre actuel d'éléments dans le tableau devient 6. Réfléchissez à la raison pour laquelle le décalage doit être effectué à partir de la fin du tableau, et non depuis le début, comme nous l'avons fait dans le cas de la suppression d'un élément du tableau.

Considérons l'implémentation logicielle de cet algorithme :

Espace de noms ConsoleApplication

Entrée int statique (sortie int n)

Console.WriteLine("entrez la dimension du tableau");

n=int.Parse(Console.ReadLine());

int a=nouveau int; // alloue plus de mémoire que nécessaire

pour (int je = 0; je< n; ++i)

Console.Write("a[(0)]= ", i);

a[i]=int.Parse(Console.ReadLine());

static void Imprimer (int a, int n)

pour (int je = 0; je< n; ++i) Console.Write("{0} ", a[i]);

Console.WriteLine();

static void AddArray (int a, ref int n, int m)

pour (int i = n; i >= m; --i)

Console.WriteLine("Entrez la valeur du nouvel élément");

a[m]=int.Parse(Console.ReadLine());

vide statique Main()

int monArray=Entrée(sortie n);

Console.WriteLine("Tableau source :");

Imprimer(monArray, n);

Console.WriteLine("Entrez le numéro de l'élément à insérer :");

AddArray(myArray, réf n,m);

Console.WriteLine("Tableau modifié :");

Imprimer(monArray, n);

Voyons maintenant ajouter une chaîne à un tableau à deux dimensions. Pour ce faire, déplacez toutes les lignes après la ligne portant le numéro k 1 ligne vers le bas. Ensuite, nous augmentons le nombre de lignes de 1. Après cela, une copie de la ligne numéro k sera dans la colonne numéro k+1. Et, par conséquent, la k-ème colonne peut être remplie de nouvelles valeurs. Considérons l'implémentation logicielle de l'algorithme :

Espace de noms ConsoleApplication

static int [,] Entrée (out int n, out int m)

Console.WriteLine("entrez la dimension du tableau");

Console.Write("n = ");

n=int.Parse(Console.ReadLine());

Console.Write("m = ");

m=int.Parse(Console.ReadLine());

// alloue plus de mémoire que nécessaire

int [,]a=nouveau int;

pour (int je = 0; je< n; ++i)

pour (int j = 0; j< m; ++j)

Console.Write("a[(0),(1)]= ", i, j);

a=int.Parse(Console.ReadLine());

static void Print(int[,] a, int n, int m)

pour (int je = 0; je< n; ++i,Console.WriteLine())

pour (int j = 0; j< m; ++j)

Console.Write("(0.5) ", a);

static void AddArray(int[,] a, ref int n, int m, int k)

pour (int i = n; i >=k; --i)

pour (int j = 0; j< m; ++j)

une = une;

pour (int j=0; j

Console.Write("a[(0),(1)]=", k, j);

a=int.Parse(Console.ReadLine());

vide statique Main()

int[,] myArray=Input(out n, out m);

Console.WriteLine("Tableau source :");

Imprimer(monArray, n, m);

int k=int.Parse(Console.ReadLine());

Console.WriteLine("Tableau modifié :");

Imprimer(monArray, n, m);

Quêtes.

1. Réfléchissez au type d'exceptions qui peuvent survenir dans un programme donné et ajoutez-y une gestion appropriée des exceptions.
2. Modifiez le programme pour ajouter la kème colonne dans un tableau à deux dimensions.

Considérons une modification du programme précédent pour le cas où un tableau échelonné est utilisé.

Espace de noms ConsoleApplication

Entrée int statique (out int n, out int m)

Console.WriteLine("entrez la dimension du tableau");

Console.Write("n = ");

n=int.Parse(Console.ReadLine());

Console.Write("m = ");

m=int.Parse(Console.ReadLine());

// alloue plus de mémoire que nécessaire

int a=nouveau int;

pour (int je = 0; je< n; ++i)

a[i]=nouveau int [m];

pour (int j = 0; j< m; ++j)

Console.Write("a[(0)][(1)]= ", i, j);

a[i][j]=int.Parse(Console.ReadLine());

static void Imprimer (int a, int n, int m)

pour (int je = 0; je< n; ++i,Console.WriteLine())

pour (int j = 0; j< m; ++j)

Console.Write("(0,5) ", a[i][j]);

static void AddArray (int a, ref int n, int m, int k)

pour (int i = n; i >=k; --i)//références de décalage

a[k]=nouveau int[m]; //crée une nouvelle ligne

Console.WriteLine("Entrer les éléments de nouvelle ligne");

pour (int j=0; j

Console.Write("a[(0)][(1)]=", k, j);

a[k][j]=int.Parse(Console.ReadLine());

vide statique Main()

int monArray=Entrée (sortie n, sortie m);

Console.WriteLine("Tableau source :");

Imprimer(monArray, n, m);

Console.WriteLine("Entrez le numéro de ligne à ajouter :");

int k=int.Parse(Console.ReadLine());

AddArray(myArray, réf n, m, k);

Console.WriteLine("Tableau modifié :");

Insérer et supprimer dans un tableau

Le principal avantage du tableau est accès directà ses éléments : pour utiliser un élément, il suffit de spécifier le nom du tableau et un ou plusieurs index, qui sont convertis en adresse physique de l'élément. La vitesse d'accès ne dépend pas de la position de l'élément dans la structure.

L'inconvénient est lié aux opérations d'insertion et de suppression d'éléments. Disons qu'un tableau unidimensionnel arrTable est utilisé pour stocker des informations utiles dans ses éléments, et que seuls les éléments initiaux, dont le nombre est Count, contiennent des informations. Ces éléments « occupés » sont appelés actif, les éléments actifs ont des index dans la plage . Évidemment, LastIndex = Count - 1. Si, par exemple, de nouvelles informations doivent être insérées dans un tableau au niveau d'un élément avec index ind, alors tous les éléments avec index, à partir de ind et jusqu'à la fin de la partie active, auront besoin à déplacer d'une position pour faire de la place à l'élément inséré NewElement. Cette opération peut être décrite par l'extrait suivant :

Pour i:=DernierIndex Vers le bas Indiana Faire

arrTable := arrTable [i];

arrTable := NouvelElement ;

Inc(Compte); Inc(DernierIndex);

Le déplacement de certains éléments signifie leur mouvement physique en mémoire. Le schéma logique de l'opération d'insertion est illustré à la figure 5.4.

Figure 5.4 - Insertion d'un nouvel élément dans un vecteur : UN- avant l'insertion, b- après insertion

La quantité de mémoire qui sera affectée lors de l'insertion d'un nouvel élément dépend de la valeur de n et du nombre d'éléments déplacés. Le temps nécessaire pour effectuer une insertion dépend du nombre d'éléments actifs dans le tableau : plus le nombre est grand, plus le décalage sera long (en moyenne).

Le même raisonnement est valable pour l’opération de suppression d’un élément actif d’un vecteur. Dans le cas de la suppression d'un élément d'index ind, tous les éléments commençant par l'élément arrTable doivent être déplacés d'une position vers le début du vecteur afin de « fermer » le « trou » créé par la suppression de l'élément. Le diagramme logique de l’opération de suppression est présenté dans la figure 5.5. Le fragment du programme de suppression peut ressembler à :

Pour je:= ind + 1 À DernierIndex Faire

arrTable := arrTable [i];

Déc(Compte); Déc(DernierIndex);

Ainsi, nous pouvons conclure : les opérations d'insertion et de suppression dans un tableau s'effectuent plus lentement à mesure que le nombre d'éléments augmente.

Un autre inconvénient important d’un tableau est que ses dimensions sont fixes. Si vous devez insérer un nouvel élément dans un tableau statique entièrement rempli d'éléments actifs, une erreur d'exécution se produira. La solution au problème consiste à utiliser un tableau dynamique, mais vous devez constamment surveiller le nombre actuel d'éléments et utiliser la procédure SetLength lors de l'insertion dans un tableau complètement rempli.

Sujet de la leçon :"Insérer et supprimer des éléments de tableau."

Article: Informatique et TIC.

Classe: 10 (profil).

Mots clés : informatique, travaux pratiques, programmation, tableaux, insertion, suppression d'éléments.

Type de cours : travaux pratiques.

Équipement: Documents à distribuer ; ordinateurs personnels.

Littérature:

Popov V.B. Turbo Pascal pour les écoliers : Manuel. allocation - 3ème ajout. éd. – M. : Finances et Statistiques, 2004, - 528 p. : ill.

Semashko G.L., Saltykov A.I. « Programmation en Pascal », M : « Nauka », 1993.

Faronov V. V. « Turbo Pascal 7.0. Cours initial", M : "Connaissances", 1997.

Objectif du travail :

comprendre les principes d'insertion et de suppression d'éléments dans des tableaux unidimensionnels et bidimensionnels,

consolider les connaissances acquises en résolvant des problèmes.

Délai de mise en œuvre: 2 leçons.

Déroulement de la leçon.

JE. Supprimer des éléments d'un tableau.

Tableau unidimensionnel

Tableau bidimensionnel

Énoncé du problème :

Étant donné un tableau A(N). Retirez l'élément situé à la position k.

Étant donné un tableau B(N,M). Supprimer le numéro de colonne k. (comme pour supprimer une ligne)

Description de la méthode de suppression :

Déplacez toute la « queue » du tableau, en commençant par le numéro d’élément k +1, d’une position vers la gauche, c’est-à-dire effectuer l'opération : a i =a i +1, où i = k, k +1, …, N -1

Le tableau résultant contiendra N -1 éléments.

Décalez toutes les colonnes commençant par k +1 jusqu'à m d'une position vers la gauche en utilisant les opérations suivantes :

Pour j de 1 à m -1 faire

une je, j =une je, j +1

Étant donné : 3 5 7 8 9 N=5, k=2

Opérations : a 2 :=a 3 ; un 3 :=un 4 ; un 4 :=un 5

Total : 3 7 8 9

Étant donné : N =3, M =4, k =2 Opérations : Résultat :

1 5 2 7 une 1.2:=une 1.3 ; une 1,3 :=une 1,4 ;

8 4 3 5 une 2.2:=une 2.3 ; une 2,3 :=une 2,4 ;

0 9 1 4 une 3.2:=une 3.3 ; un 3,3 :=un 3,4 ;

Programme

Randomiser ;

Writeln('Entrez le nombre d'éléments');

Lecture(n);

Writeln('Entrez le numéro de l'élément à supprimer');

Lire(k);

(formation de tableau au hasard)

Pour i:=1 à n, commencez

a[i]:=aléatoire(101)-50 ;

fin ;

écrire ;

(supprimer un élément spécifié)

Pour i:=k à n-1 faire

(produit le tableau final)

Pour i:=1 à n-1 faire

clrscr; randomiser;

writeln("Entrez le nombre de lignes de colonnes");

writeln("Entrez le numéro de colonne à supprimer");

pour i:=1 à n, commencez (nous formons un tableau)

pour j:=1 à m commencez

b:=51*aléatoire-25 ;

écrire(b:8:2)

pour j:=k à m-1 do (supprimer la k-ième colonne)

pour i:=1 à n faire

b:=b;

(nous affichons le tableau résultant)

pour i:=1 à n, commence

pour j:=1 à m-1 commencez

écrire(b:8:2)

Dans un tableau unidimensionnel A (N), recherchez l'élément min et supprimez-le.

Dans un tableau bidimensionnel B (N, M), supprimez le numéro de ligne k. En même temps, vérifiez si la valeur k dépasse le nombre de lignes du tableau B .

II. Insérer (y compris) des éléments dans un tableau.

Tableau unidimensionnel

Tableau bidimensionnel

Énoncé du problème :

Étant donné un tableau A(N). Incluez à la place k dans ce tableau un élément égal à m .

Étant donné un tableau B(N,M). Ajoutez le numéro de colonne k. Les éléments de la nouvelle colonne sont égaux aux éléments du tableau C(N) (Similaire pour l'ajout d'une ligne)

Description de la méthode de suppression :

Avant d'inclure un élément donné dans un tableau, il est nécessaire d'étendre ce tableau, c'est-à-dire déplacez la « queue » du tableau vers la droite d’une position, c’est-à-dire effectuer l'opération : a i +1 =a i, où i = N, N -1, ..., k. Nous commençons à déplacer les éléments du tableau à partir de la fin, sinon toute la queue du tableau sera remplie du kième élément.

La taille du tableau augmentera à N +1 éléments.

Déplacez toutes les colonnes commençant par m vers k d'une position vers la droite en utilisant les opérations suivantes :

pour j de m à k faire

Parcourez toutes les lignes de 1 à n en faisant

une je , j +1 = une je , j

Alors dans i = 1ère n lignes a i , k :=c i

Le nouveau tableau aura M -1 colonnes.

Important: lors de l'ajout d'une colonne (ligne) à un tableau à deux dimensions, les éléments de cette colonne (ligne) sont extraits d'un tableau unidimensionnel supplémentaire de taille = nombre de lignes d'un tableau à deux dimensions (= nombre de colonnes) ou sont entrés depuis le clavier.

Étant donné : 3 8 7 6 5 N=5, k=2, m=4

Opérations : a 6 :=a 5 =5 ; un 5 :=un 4 =6; un 4 :=un 3 =7; un 3 :=un 2 =8

Total : 3 4 8 7 6 5

Étant donné : N =3, M =4, k =3 Opérations : Résultat :

C(N)=(6,8,2) une 1,5 :=une 1,4 ; une 1,4 :=une 1,3 ;

1 5 2 7 une 2,5 :=une 2,4 ; une 2,4 :=une 2,3 ;

8 4 3 5 une 3,5 :=une 3,4 ; un 3,4 :=un 3,3 ;

Programme

Var a: tableau d'entiers ;

n,k,i:octet; m:entier;

Writeln("Entrez le nombre d'éléments");

Writeln("Entrez le numéro de l'élément à inclure");

Lire(k);

Writeln("Entrez la valeur de l'élément à inclure");

(on forme un tableau)

Pour i:=1 à n, commencez

a[i]:=aléatoire(101)-50 ;

fin ; écrire ;

(répartir les éléments du tableau)

Pour i:=n jusqu'à k faire

une :=une ;

(on ajoute un nouvel élément à la kème position)

une :=m ;

(nous affichons le tableau résultant)

Pour i:=1 à n+1 faire

var b: tableau de réels ; je,j,m,n,k:octet;

c: tableau de réels ;

clrscr; randomiser;

writeln("Entrez le nombre de lignes et de colonnes");

readln(n,m);

writeln("Entrez le numéro de colonne à ajouter");

pour i:=1 à n, commencez (nous formons le tableau initial)

pour j:=1 à m commencez

b:=51*aléatoire-25 ;

écrire(b:8:2)

fin;écriture;fin;écriture;

pour i:=1 à n, commencez (formez un tableau de colonnes supplémentaires)

c[i]:=51*aléatoire-25 ; écrire(c[i]:8:2)

fin; écrire; écrire;

pour j:=m jusqu'à k do (écarter les colonnes)

pour i:=1 à n faire

b:=b;

pour i:=1 à n do (ajouter une colonne)

pour i:=1 à n, commencez (affichez le tableau résultant)

pour j:=1 à m+1 commencez

écrire(b:8:2)

fin; lire en fin de compte.

Tâches pour une solution indépendante :

Dans un tableau unidimensionnel A (N), recherchez l'élément max et insérez après lui un élément égal à 2*max.

Dans un tableau bidimensionnel B (N,M), insérez la k-ème ligne d'éléments du tableau C (M). En même temps, vérifiez si la valeur k dépasse le nombre de lignes du tableau B .

fin; (pour moi)

Insérer et supprimer un élément dans un tableau

Considérons l'algorithme d'insertion d'un élément dans un tableau. Par souci de simplicité, nous ne considérerons que les tableaux unidimensionnels. Le tableau est constitué d'un certain nombre d'éléments nmax (capacité

tableau). Le nombre actuel d'éléments du tableau se trouve dans la variable n.

Avant d'insérer l'élément suivant, on vérifie que le nombre actuel d'éléments du tableau est inférieur à sa capacité.

Ensuite, nous vérifions si l'élément est inséré ou non à la fin du tableau. Si un élément est inséré à la fin du tableau, augmentez n de un et ajoutez l'élément. Sinon, on décale les éléments du tableau dont l'index est supérieur ou égal à l'index de l'élément inséré, Figure 3.

L'algorithme ci-dessus est implémenté dans le programme présenté dans le listing 6.

Listing 6 – Insérer un élément dans un tableau

($MODE DELPHI) ($ENDIF)

($APPTYPE CONSOLE) programme InsElt ;

je :entier;

//Tableau d'entrée

//Élément à insérer writeln("Élément Vvedite" ); readln(élément);

//Indice de l'élément

//Insérer un élément

si indice< n+1 then begin

inc(n); // augmente la longueur du tableau

si (Faible(a)<= index) and (index <= n) then for i:=n downto index do

une[je]:=une; //décalage du tableau

a:=élément ; fin

//Afficher les éléments du tableau à l'écran pour i:=1 à n do

writeln("a[" , i,"]=" , a[i]:6:2);

La suppression d'un élément s'effectue de la même manière. Tout d'abord, il vérifie que l'index de l'élément est dans la plage des valeurs acceptables, puis décale les éléments de manière à recouvrir l'élément à supprimer, Figure 4.

Liste 7

($MODE DELPHI) ($ENDIF)

($APPTYPE CONSOLE) programme DelElt ;

const nmax = 5 ; //capacité du tableau

je :entier;

writeln("Vvedite chislo elementov massiva"); readln(n);

//Tableau d'entrée

pour i:=1 à n, commencez write("a[" , i,"]=" ); readln(a[i]);

//Indice de l'élément

writeln("Élément d'index actuel"); readln(index);

//Suppression d'éléments

si indice

si (Faible(a)<= index) and (index <= n) then for i:=index to n do

une[je]:=une; //tableau shiftdec(n); //réduire la longueur de la fin du tableau

sinon commencez writeln("Index invalide" ); lire;