Come invertire un array C ++
Il contrario di questo array è:
char arrr [] = 'q', 'p', 'o', 'n', 'm';I caratteri diventano inversa, in inizializer_list. Si noti che nell'ordine inverso, la lettera, 'o' rimane nella sua posizione. Questo perché il numero di elementi nell'array è dispari.
Considera ora il seguente array:
char arrf [] = 'l', 'm', 'n', 'o', 'p', 'q';Il contrario di questo array è:
char arrr [] = 'q', 'p', 'o', 'n', 'm', 'l';I caratteri diventano inversa, in inizializer_list. Questa volta, i due elementi di mezzo sono scambiati perché il numero di elementi nell'array è persino.
Esistono vari modi per invertire l'array e questo articolo esplora questi modi.
Contenuto dell'articolo
- Introduzione - Vedi sopra
- Utilizzando un array extra per invertire
- Array inverso scambiando elementi
- Array di inversione usando una funzione ricorsiva
- Uso di std :: reverse ()
- Conclusione
Utilizzando un array extra per invertire
Con questo metodo, crea un altro array dello stesso tipo e dimensioni dell'array originale ma vuoto. Successivamente, leggi il primo array dalla parte posteriore e inserisci gli elementi nel secondo array dalla parte anteriore utilizzando un ad anello. Il seguente programma illustra questo:
#includereUtilizzo dello spazio dei nomi std;
int main ()
char arrf [] = 'm', 'n', 'o', 'p', 'q';
int size = sizeof (arrf)/sizeof (arrf [0]); // Ottenere le dimensioni dell'array
char arrr [dimensione];
per (int i = 0, j = size-1; j> = 0; i ++, j--)
arrr [i] = arrf [j];
per (int i = 0; i
cout<
L'output è:
Q p o n mLa prima istruzione nella funzione principale C ++ crea il primo array senza indicare la dimensione. La seconda istruzione ottiene la dimensione dividendo la dimensione totale dell'array in byte per le dimensioni del primo elemento dell'array (dopo tutto, tutti gli elementi di un array C ++, sono dello stesso tipo). L'istruzione successiva crea il secondo array dello stesso tipo e dimensioni, ma vuota.
Il segmento di codice dopo è il per loop. Il per loop copia l'ultimo elemento del primo array e lo mette nella prima posizione del secondo array. Copia l'ultimo ma uno elemento del primo array e mette nella seconda posizione del secondo array. Copia l'elemento terzo a ultimo del primo array e mette nella terza posizione del secondo array e fino a quando l'indice variabile, I che "si muove" Il secondo array raggiunge l'ultimo elemento del secondo array all'indice Size-1. INDICE, J "si sposta verso il basso" il primo array da Size-1 a 0. Sollevo il secondo array mentre J si sposta lungo il primo array.
Nelle parentesi del per loop, io e J sono dichiarati nella prima affermazione. Finché J è maggiore o uguale a zero, la copia continuerà - questa è la condizione while. L'incremento di I e il decremento di J, formano l'ultima affermazione tra parentesi.
L'ultimo per loop stampica gli elementi del secondo array.
Array inverso scambiando elementi
Gli ultimi e i primi elementi possono essere scambiati con l'unico array. L'ultimo ma uno e secondi elementi possono essere scambiati con questo stesso array. Il terzo e il terzo elementi possono essere scambiati e fino a quando il punto centrale dell'array è raggiungibile e lo scambio di arresti. Se il numero di elementi è dispari, l'elemento centrale non cambia posizione. Se il numero di elementi è uniforme, allora ci sono due elementi intermedi che vengono scambiati.
Ancora una volta, ci sono due variabili dell'indice: io e j ma per un solo array. Sono incrementato e J è decrementato per ogni iterazione fino a quando non si incontrano quasi. La condizione di tempo per questo è, (io < j). The following program, illustrates this method:
#includereUtilizzo dello spazio dei nomi std;
int main ()
char arr [] = 'm', 'n', 'o', 'p', 'q';
int size = sizeof (arr)/sizeof (arr [0]);
per (int i = 0, j = size-1; i< j; i++,j--)
char temp = arr [i];
arr [i] = arr [j];
arr [j] = temp;
per (int i = 0; i
cout<
L'output è:
Q p o n mArray di inversione usando una funzione ricorsiva
Una funzione ricorsiva è una funzione che continua a chiamarsi fino a quando non viene soddisfatta una condizione. Questo è meglio spiegato con un esempio. Considera la seguente parte superiore del programma:
#includereUtilizzo dello spazio dei nomi std;
char arr [] = 'm', 'n', 'o', 'p', 'q';
int siz = sizeof (arr)/sizeof (arr [0]);
void inversarray (char arr [], int i)
// Condizione di base
if (i == siz)
ritorno;
char element = arr [i]; // Elemento di estrazione
reversarray (arr, i+1); // chiamata ricorsiva
arr [siz-i-1] = elemento; //rintracciare
L'array viene dichiarato e la dimensione dell'array è determinata come siz (senza e). Dopodiché nel codice è la definizione della funzione ricorsiva. Il primo segmento di codice nella funzione (If-costruct) è la condizione da soddisfare. I è la variabile dell'indice per accedere agli elementi dell'array dall'indice 0 all'indice Siz-1. Quando sono uguale a Siz, la funzione ritorna e smette di chiamarsi.
La funzione principale C ++ ha la chiamata,
reversarray (arr, 0);Questo chiama la funzione ricorsiva con due argomenti: il primo è il nome dell'array; Il secondo è l'indice iniziale per i, zero.
Quando la funzione viene chiamata la prima volta, 'M' viene assegnata a una posizione in memoria identificata dall'elemento. Dopo questa affermazione, la funzione viene nuovamente chiamata all'interno della funzione con "InversiArray (arr, I+1);". L'ultima affermazione nella funzione non è stata seguita. Questa volta la funzione viene chiamata con i = 1; e 'n' è assegnato a una posizione di memoria diversa, ancora identificata da, elemento.
La terza volta viene chiamata la funzione, i = 2; e 'O' è assegnato a una terza posizione di memoria ancora identificata l'elemento Byrem. La quarta volta viene chiamata la funzione, i = 3; e "p" è assegnato a un quarto remstill di posizione della memoria identificata dall'elemento. La quinta volta viene chiamata la funzione, i = 4; e "Q" è assegnato a una quinta posizione di memoria ancora identificata dall'elemento.
La sesta volta viene chiamata la funzione, i = 5 che ha la dimensione dell'array e la funzione ritorna a causa della costruzione IF. Per tutto questo tempo, l'ultima affermazione nella funzione non è stata seguita. Quest'ultima affermazione è:
arr [siz-i-1] = elemento;Con questa affermazione, qualunque cosa sia tenuta dall'elemento, è assegnato a una posizione di array. Ricorda che ci sono cinque posizioni in memoria con l'elemento identificativo che tiene i personaggi: "M", "N", "O", "P", "Q", in quell'ordine.
È vero che la funzione ha restituito vuoto, ma l'ultima affermazione deve ancora essere eseguita, cinque volte. Per ogni chiamata della funzione, l'ultima istruzione è stata registrata una volta, in memoria. La prima volta che esegue, siz -i -1 = 5 - 0 - 1 = 4; alla chiamata per la quale restituisce la funzione, ma utilizzando il primo indice. E così,
arr [4] = 'q'andare all'indietro. La seconda volta che l'ultima istruzione esegue, siz -i -1 = 5 - 1 - 1 = 3. E così,
arr [3] = 'p'
La terza volta che l'ultima istruzione esegue, siz -i -1 = 5 - 2 - 1 = 2. E così,
arr [2] = 'o'
La quarta volta che l'ultima istruzione esegue, siz -i -1 = 5 - 3 - 1 = 1. E così,
arr [1] = 'n'
La quinta e l'ultima volta l'ultima istruzione esegue, siz -i -1 = 5 - 4 - 1 = 0. E così,
arr [0] = 'm'
E così l'array è stato invertito con una funzione ricorsiva.
Uso di std :: reverse ()
Lo std :: revers () della libreria dell'algoritmo può anche essere usato per invertire un array sebbene non sia ovvio. Per utilizzare questa funzione, la libreria dell'algoritmo deve essere inclusa nel programma. Il prototipo per la funzione è:
modelloContexpr void Reverse (bidirectionaliterator prima, bidirezionalteratore per ultimo);
Il primo argomento è un iteratore che punta al primo elemento di un contenitore. Il secondo argomento è un altro iteratore che punta subito dopo l'ultimo elemento del contenitore. Un puntatore al primo elemento dell'array può essere usato come primo argomento. Un puntatore che punta subito dopo l'ultimo elemento dell'array può essere usato come secondo argomento.
Se il nome dell'array è ARR, allora un puntatore al primo elemento è arr. Un puntatore che punta subito dopo l'ultimo elemento dell'array è "ARR + Dimensione" dove la dimensione è la dimensione dell'array. Il seguente programma, mostra come STD :: reverse () può essere usato per invertire un array:
#includere#includere
Utilizzo dello spazio dei nomi std;
char arr [] = 'm', 'n', 'o', 'p', 'q';
int siz = sizeof (arr)/sizeof (arr [0]); // Dimensione dell'array
int main ()
retromarcia (arr, arr+siz);
per (int i = 0; i
cout<
L'output è:
Q p o n mConclusione
L'inversione di un array può essere fatto, usando un array extra, scambiando elementi di array, usando una funzione ricorsiva o usando std :: reverse ().