Wie man ein C ++ - Array umgeht
Die Rückseite dieses Arrays ist:
char arrr [] = 'q', 'p', 'o', 'n', 'm';Die Zeichen werden in umgekehrter Reihenfolge in der Initializer_List entstehen. Beachten Sie, dass in umgekehrter Reihenfolge, Buchstabe 'O' an seiner Position bleibt. Dies liegt daran, dass die Anzahl der Elemente im Array ungerade ist.
Betrachten Sie jetzt das folgende Array:
char arrf [] = 'l', 'm', 'n', 'o', 'p', 'q';Die Rückseite dieses Arrays ist:
char arrr [] = 'q', 'p', 'o', 'n', 'm', 'l';Die Zeichen werden in umgekehrter Reihenfolge in der Initializer_List entstehen. Diesmal werden die mitteen beiden Elemente ausgetauscht, weil die Anzahl der Elemente im Array gerade ist.
Es gibt verschiedene Möglichkeiten, das Array umzukehren, und dieser Artikel untersucht diese Wege.
Artikelinhalt
- Einführung - siehe oben
- Verwenden eines zusätzlichen Arrays zum Umkehren
- Umgekehrter Array durch Tauschelemente
- Umkehrungsarray unter Verwendung einer rekursiven Funktion
- Verwendung von std :: reverse ()
- Abschluss
Verwenden eines zusätzlichen Arrays zum Umkehren
Erstellen Sie mit dieser Methode ein anderes Array mit demselben Typ und der gleichen Größe wie das ursprüngliche Array, aber leer, aber leer. Lesen Sie als nächstes das erste Array von hinten und passen Sie die Elemente im zweiten Array von vorne mit einem For-Loop ein. Das folgende Programm zeigt dies:
#enthaltenVerwenden von Namespace STD;
int main ()
char arrf [] = 'm', 'n', 'o', 'p', 'q';
int size = sizeof (arrf)/sizeof (arrf [0]); // die Größe des Arrays erhalten
char arrr [Größe];
für (int i = 0, j = size-1; j> = 0; i ++, j-)
arrr [i] = arrf [j];
für (int i = 0; i
Cout<
Die Ausgabe ist:
Q P o n mDie erste Anweisung in der C ++ - Hauptfunktion erstellt das erste Array, ohne die Größe anzugeben. Die zweite Aussage erhält die Größe, indem die Gesamtgröße des Arrays in Bytes durch die Größe des ersten Elements des Arrays geteilt wird (schließlich sind alle Elemente eines C ++ - Arrays vom gleichen Typ). Die nächste Anweisung erstellt das zweite Array mit demselben Typ und derselben Größe, aber leer, aber leer.
Das Codesegment danach ist der For-Loop. Die For-Loop kopiert das letzte Element des ersten Arrays und setzt es in die erste Position des zweiten Arrays. Es kopiert das letzte, aber ein Element des ersten Arrays und stellt in die zweite Position des zweiten Arrays ein. Es kopiert das dritte Element des ersten Arrays und stellt in die dritte Position des zweiten Arrays und bis zum variablen Index wird das zweite Array das letzte Element des zweiten Arrays am Index „verschieben“ Größe 1. Index, J „bewegt sich nach unten“ das erste Array von Größe 1 auf 0. Ich bewegte mich das zweite Array hinauf, während J das erste Array entlang bewegt.
In den Klammern der For-Loop werden ich und j in der ersten Erklärung deklariert. Solange J größer oder gleich Null ist, wird das Kopieren fortgesetzt - das ist die Bedingung. Das Inkrement von I und Dekrement von J bilden die letzte Aussage in den Klammern.
Der letzte Aufsatz druckt die Elemente des zweiten Arrays aus.
Umgekehrter Array durch Tauschelemente
Die letzten und ersten Elemente können gegen das einzige Array getauscht werden. Die letzten, aber ein- und zweiten Elemente können gegen das gleiche Array ausgetauscht werden. Die dritten zu lassen und dritten Elemente können ausgetauscht werden und bis der Mittelpunkt des Arrays erreicht ist und tauschte Stops. Wenn die Anzahl der Elemente ungerade ist, ändert das mittlere Element seine Position nicht. Wenn die Anzahl der Elemente ausgeglichen ist, gibt es zwei Mittelelemente, die getauscht werden.
Auch hier gibt es zwei Indexvariablen: I und J, aber nur für ein Array. Ich bin inkrementiert und J ist für jede Iterationr abgeschlossen, bis sie sich fast treffen. Die Zeit dafür ist (ich < j). The following program, illustrates this method:
#enthaltenVerwenden von Namespace STD;
int main ()
char arr [] = 'm', 'n', 'o', 'p', 'q';
int size = sizeof (arr)/sizeof (arr [0]);
für (int i = 0, j = size-1; i< j; i++,j--)
char temp = arr [i];
arr [i] = arr [j];
arr [j] = temp;
für (int i = 0; i
Cout<
Die Ausgabe ist:
Q P o n mUmkehrungsarray unter Verwendung einer rekursiven Funktion
Eine rekursive Funktion ist eine Funktion, die sich immer wieder aufruft, bis eine Bedingung erfüllt ist. Dies wird besser mit einem Beispiel erklärt. Betrachten Sie den folgenden oberen Teil des Programms:
#enthaltenVerwenden von Namespace STD;
char arr [] = 'm', 'n', 'o', 'p', 'q';
int siz = sizeof (arr)/sizeof (arr [0]);
void Reversearray (char arr [], int i)
// Basiszustand
if (i == Siz)
zurückkehren;
char element = arr [i]; // Element extrahieren
Reversearray (arr, i+1); // rekursiver Anruf
arr [Siz-i-1] = Element; //zurück verfolgen
Das Array wird deklariert und die Größe des Arrays wird als Siz (ohne E) bestimmt. Danach im Code befindet sich die rekursive Funktionsdefinition. Das erste Codesegment in der Funktion (If-Construct) ist die zu ertragende Bedingung. Das I ist die Indexvariable für den Zugriff auf die Array-Elemente von Index 0 bis Index Siz-1. Wenn ich Siz gleich ist, kehrt die Funktion zurück und hört auf, sich selbst anzurufen.
Die C ++ - Hauptfunktion hat den Anruf,
Reversearray (arr, 0);Dies ruft die rekursive Funktion mit zwei Argumenten auf: Der erste ist der Name des Arrays; Der zweite ist der Anfangsindex für i, null.
Wenn die Funktion als erstes Mal aufgerufen wird, wird 'M' einem von Element identifizierten Speicherort im Speicher zugeordnet. Nach dieser Anweisung wird die Funktion in der Funktion erneut mit "Reversearray (arr, i+1) aufgerufen;. Die letzte Aussage in der Funktion wurde nicht angesprochen. Diesmal wird die Funktion mit i = 1 aufgerufen; und 'n' wird einem anderen Speicherort zugeordnet, das immer noch durch Element identifiziert wird.
Das dritte Mal wird die Funktion aufgerufen, i = 2; und 'o' wird einem dritten Speicherort zugeordnet, der noch das Byrem -Element identifiziert hat. Das vierte Mal wird die Funktion aufgerufen, i = 3; und 'P' wird einem vierten Speicherort -Remstill zugewiesen, der durch Element identifiziert wurde. Das fünfte Mal wird die Funktion aufgerufen, i = 4; und 'Q' wird einem fünften Speicherort zugeordnet, der immer noch nach Element identifiziert wird.
Das sechste Mal wird die Funktion aufgerufen, i = 5, die Größe des Arrays und die Funktion kehrt aufgrund des If-Construct zurück. Währenddessen wurde die letzte Aussage in der Funktion nicht behandelt. Diese letzte Aussage lautet:
arr [Siz-i-1] = Element;Mit dieser Erklärung wird eine von Element gehaltene, einer Array -Position zugeordnet. Denken Sie daran, dass es fünf Stellen im Speicher gibt, wobei das Identifierelement die Zeichen hält: 'M', 'n', 'o', 'p', 'q', in dieser Reihenfolge.
Es ist wahr, dass die Funktion void zurückgegeben hat, aber die letzte Aussage muss noch fünf Mal ausgeführt werden. Für jeden Anruf der Funktion wurde die letzte Anweisung einmal im Speicher aufgezeichnet. Das erste Mal, dass es ausgeführt wird, Siz -i -1 = 5 - 0 - 1 = 4; am Anruf, für den die Funktion zurückgibt, aber den ersten Index verwendet. Und so,
arr [4] = 'q'rückwärts gehen. Das zweite Mal, dass die letzte Anweisung ausgeführt wird, Siz -i -1 = 5 - 1 - 1 = 3. Und so,
arr [3] = 'P'
Das dritte Mal, dass die letzte Anweisung ausgeführt wird, Siz -i -1 = 5 - 2 - 1 = 2. Und so,
arr [2] = 'o'
Das vierte Mal, dass die letzte Aussage ausgeführt wird, Siz -i -1 = 5 - 3 - 1 = 1. Und so,
arr [1] = 'n'
Das fünfte und letzte Mal, dass die letzte Aussage ausgeführt wird, Siz -i -1 = 5 - 4 - 1 = 0. Und so,
arr [0] = 'M'
Und so wurde das Array mit einer rekursiven Funktion umgekehrt.
Verwendung von std :: reverse ()
Das std :: reverse () der Algorithmusbibliothek kann auch verwendet werden, um ein Array umzukehren, obwohl es nicht offensichtlich ist. Um diese Funktion zu verwenden, muss die Algorithmus -Bibliothek in das Programm aufgenommen werden. Der Prototyp für die Funktion lautet:
Vorlagecontexpr void reverse (Bidirectionaliterator zuerst, Bidirectionaliterator zuletzt);
Das erste Argument ist ein Iterator, der auf das erste Element eines Containers zeigt. Das zweite Argument ist ein weiterer Iterator, der kurz nach dem letzten Element des Containers zeigt. Ein Zeiger auf das erste Element des Arrays kann als erstes Argument verwendet werden. Ein Zeiger, der kurz nach dem letzten Element des Arrays zeigt, kann als zweites Argument verwendet werden.
Wenn der Array -Name arr ist, ist ein Zeiger auf das erste Element arr. Ein Zeiger, der kurz nach dem letzten Element des Arrays zeigt. Das folgende Programm zeigt, wie std :: reverse () verwendet werden kann, um ein Array umzukehren:
#enthalten#enthalten
Verwenden von Namespace STD;
char arr [] = 'm', 'n', 'o', 'p', 'q';
int siz = sizeof (arr)/sizeof (arr [0]); // Größe des Arrays
int main ()
reverse (arr, arr+siz);
für (int i = 0; i
Cout<
Die Ausgabe ist:
Q P o n mAbschluss
Das Umkehren eines Arrays kann mit einem zusätzlichen Array durchgeführt werden, indem Array -Elemente ausgetauscht, durch Verwendung einer rekursiven Funktion oder durch Verwendung von std :: reverse ().