Comment inverser un tableau C ++
L'inverse de ce tableau est:
char arrr [] = 'q', 'p', 'o', 'n', 'm';Les personnages deviennent dans l'ordre inverse, dans l'initialiseur_list. Notez que dans l'ordre inverse, la lettre, «o» reste à sa position. C'est parce que le nombre d'éléments dans le tableau est étrange.
Considérez maintenant le tableau suivant:
char arrf [] = 'l', 'm', 'n', 'o', 'p', 'q';L'inverse de ce tableau est:
char arrr [] = 'q', 'p', 'o', 'n', 'm', 'l';Les personnages deviennent dans l'ordre inverse, dans l'initialiseur_list. Cette fois, les deux éléments du milieu sont échangés car le nombre d'éléments dans le tableau est même.
Il existe différentes façons d'inverser le tableau, et cet article explore ces façons.
Contenu de l'article
- Introduction - Voir ci-dessus
- Utilisation d'un tableau supplémentaire pour inverser
- Répartir le tableau en échangeant des éléments
- Inversion du tableau à l'aide d'une fonction récursive
- Utilisation de Std :: Reverse ()
- Conclusion
Utilisation d'un tableau supplémentaire pour inverser
Avec cette méthode, créez un autre tableau du même type et de la même taille que le tableau d'origine mais vide. Ensuite, lisez le premier tableau à l'arrière et installez-vous dans les éléments du deuxième tableau de l'avant à l'aide d'une boucle pour. Le programme suivant illustre ceci:
#inclureUtilisation de Namespace Std;
int main()
char arrf [] = 'm', 'n', 'o', 'p', 'q';
int size = sizeof (arrf) / sizeof (Arrf [0]); // Obtention de la taille du tableau
char arrr [taille];
pour (int i = 0, j = size-1; j> = 0; i ++, j--)
Arrr [i] = arrf [j];
pour (int i = 0; i
couter<
La sortie est:
Q p o n mLa première instruction de la fonction principale C ++ crée le premier tableau sans indiquer la taille. La deuxième déclaration obtient la taille en divisant la taille totale du tableau en octets par la taille du premier élément du tableau (après tout, tous les éléments d'un tableau C ++, sont du même type). La déclaration suivante crée le deuxième tableau du même type et de la même taille, mais vide.
Le segment de code après est la boucle pour. La boucle For-Copie le dernier élément du premier tableau et le met en première position du deuxième tableau. Il copie l'élément dernier mais un du premier tableau et met en deuxième position du deuxième tableau. Il copie l'élément de troisième au dernier du premier tableau et met en troisième position du deuxième tableau et jusqu'à l'indice variable, je «déplace» le deuxième tableau atteint le dernier élément du deuxième tableau à l'index taille-1. Index, j «se déplace» le premier tableau de taille 1 à 0. Je remonte le deuxième tableau tandis que J déménage le premier tableau.
Dans les parenthèses de la boucle for, I et J sont déclarés dans la première déclaration. Tant que J est supérieur ou égal à zéro, la copie se poursuivra - c'est-à-dire la condition. L'incrément de I et la décrémentation de J, forment la dernière déclaration dans les parenthèses.
Le dernier boucle pour imprimer les éléments du deuxième tableau.
Répartir le tableau en échangeant des éléments
Les derniers et premiers éléments peuvent être échangés pour le seul tableau. Les derniers mais un deuxième éléments peuvent être échangés contre ce même tableau. Les troisième au dernier et troisième éléments peuvent être échangés et jusqu'à ce que le point médian du tableau soit atteint et échange des arrêts. Si le nombre d'éléments est impair, l'élément central ne change pas sa position. Si le nombre d'éléments est uniforme, il y a deux éléments intermédiaires qui sont échangés.
Encore une fois, il y a deux variables d'index: I et J mais pour un tableau seulement. I est incrémenté et J est décrémenté pour chaque itération jusqu'à ce qu'ils se rencontrent presque. La condition de ce qui est à ce sujet est (je < j). The following program, illustrates this method:
#inclureUtilisation de Namespace Std;
int main()
char arr [] = 'm', 'n', 'o', 'p', 'q';
int size = sizeof (arr) / sizeof (arr [0]);
pour (int i = 0, j = size-1; i< j; i++,j--)
char temp = arr [i];
arr [i] = arr [j];
arr [j] = temp;
pour (int i = 0; i
couter<
La sortie est:
Q p o n mInversion du tableau à l'aide d'une fonction récursive
Une fonction récursive est une fonction qui continue de s'appeler jusqu'à ce qu'une condition soit remplie. Cela est mieux expliqué avec un exemple. Considérez la partie supérieure suivante du programme:
#inclureUtilisation de Namespace Std;
char arr [] = 'm', 'n', 'o', 'p', 'q';
int siz = sizeof (arr) / sizeof (arr [0]);
void reversearray (char arr [], int i)
// Condition de base
if (i == siz)
retour;
element char = arr [i]; // Élément d'extraction
reversEARRAY (arr, i + 1); // appel récursif
arr [siz-i-1] = élément; // Traceback
Le tableau est déclaré et la taille du tableau est déterminée comme siz (sans e). Après cela dans le code est la définition de la fonction récursive. Le premier segment de code de la fonction (IF-Construct) est la condition à remplir. Le i est la variable d'index pour accéder aux éléments du tableau de l'index 0 à l'index SIZ-1. Quand je suis égal à la taille, la fonction retourne et cesse de s'appeler.
La fonction principale C ++ a l'appel,
reversEARRAY (arr, 0);Cela appelle la fonction récursive avec deux arguments: le premier est le nom du tableau; Le second est l'indice de début pour i, zéro.
Lorsque la fonction est appelée la première fois, «m» est affecté à un emplacement dans la mémoire identifié par élément. Après cette instruction, la fonction est à nouveau appelée dans la fonction avec «ReverseArray (arr, i + 1);». La dernière déclaration de la fonction n'a pas été prise. Cette fois, la fonction est appelée avec i = 1; et 'n' est affecté à un autre emplacement de mémoire, toujours identifié par l'élément.
La troisième fois, la fonction est appelée, i = 2; et «O» est affecté à un troisième emplacement de mémoire encore identifié l'élément Byrem. La quatrième fois la fonction est appelée, i = 3; et «p» est affecté à un quatrième emplacement de mémoire, ce qui est identifié par élément identifié par élément. La cinquième fois la fonction est appelée, i = 4; et «q» est affecté à un cinquième emplacement mémoire encore identifié par élément.
La sixième fois que la fonction est appelée, i = 5 qui est la taille du tableau et la fonction renvoie en raison de l'IF-Construct. Pendant tout ce temps, la dernière déclaration de la fonction n'a pas été prise. Cette dernière déclaration est:
arr [siz-i-1] = élément;Avec cette déclaration, tout ce qui est détenu par Element, est affecté à une position de tableau. N'oubliez pas qu'il y a cinq emplacements en mémoire avec l'élément identifiant tenant les caractères: «m», «n», «o», «p», «q», dans cet ordre.
Il est vrai que la fonction est revenue vide, mais la dernière instruction doit encore être exécutée, cinq fois. Pour chaque appel de la fonction, la dernière instruction a été enregistrée une fois, en mémoire. La première fois qu'il s'exécute, siz-i-1 = 5 - 0 - 1 = 4; à l'appel pour lequel la fonction renvoie, mais en utilisant le premier index. Et ainsi,
arr [4] = 'q'reculer. La deuxième fois que la dernière instruction s'exécute, siz-i-1 = 5 - 1 - 1 = 3. Et ainsi,
arr [3] = 'p'
La troisième fois la dernière instruction s'exécute, siz-i-1 = 5 - 2 - 1 = 2. Et ainsi,
arr [2] = 'o'
La quatrième fois que la dernière instruction s'exécute, siz-i-1 = 5 - 3 - 1 = 1. Et ainsi,
arr [1] = 'n'
La cinquième et dernière fois que la dernière instruction s'exécute, siz-i-1 = 5 - 4 - 1 = 0. Et ainsi,
arr [0] = 'm'
Et donc le tableau a été inversé avec une fonction récursive.
Utilisation de Std :: Reverse ()
La std :: reverse () de la bibliothèque d'algorithme peut également être utilisée pour inverser un tableau bien qu'il ne soit pas évident. Pour utiliser cette fonction, la bibliothèque d'algorithmes doit être incluse dans le programme. Le prototype de la fonction est:
modèleConsxpr void Inverse (BidirectionAllitorator First, BidirectionAlliterator Last);
Le premier argument est un itérateur pointant vers le premier élément d'un conteneur. Le deuxième argument est un autre itérateur pointant juste après le dernier élément du conteneur. Un pointeur vers le premier élément du tableau peut être utilisé comme premier argument. Un pointeur pointant juste après le dernier élément du tableau peut être utilisé comme deuxième argument.
Si le nom du tableau est Arr, alors un pointeur vers le premier élément est Arr. Un pointeur pointant juste après le dernier élément du tableau est la «taille ARR +» où la taille est la taille du tableau. Le programme suivant montre comment std :: reverse () peut être utilisé pour inverser un tableau:
#inclure#inclure
Utilisation de Namespace Std;
char arr [] = 'm', 'n', 'o', 'p', 'q';
int siz = sizeof (arr) / sizeof (arr [0]); // Taille du tableau
int main()
inverse (arr, arr + siz);
pour (int i = 0; i
couter<
La sortie est:
Q p o n mConclusion
L'inversion d'un tableau peut être effectuée, en utilisant un tableau supplémentaire, en échangeant des éléments du tableau, en utilisant une fonction récursive, ou en utilisant std :: reverse ().