Come si uniscono gli array in C++?
In C ++, c'è un problema tecnico, nel senso che si verificano tre array invece di un nuovo array unita. Non sarebbe bello eliminare i vecchi due array dopo la fusione e la memoria inutilizzata gratuita? C ++ ha due modi per un fusione di due array: se i due array si sono uniti, hanno usato la memoria dinamica, quindi possono essere eliminati per finire con un array; Altrimenti, il programmatore finisce con tre array.
La fusione di array alla fine si adattava a uno sul retro dell'altro è buono; ma può essere meglio avere un po 'di smistamento minimo poiché gli array vengono uniti. L'ordinamento nel suo insieme è un intero argomento nella programmazione. L'ordinamento nel suo insieme non è affrontato in questo articolo. Tuttavia, viene affrontato un smistamento minimo molto semplice.
Questo articolo spiega come unire due array, per finire con tre array e come unire due array per finire con un array. Viene anche considerato un po 'di ordinamento minimo. Per unire due array, i due array devono essere dello stesso tipo.
La procedura di fusione di due array può essere estesa a più di due array.
Contenuto dell'articolo
- Unendo gli array senza negozio gratuito
- Unendo gli array usando il negozio gratuito
- Conclusione
Unendo gli array senza negozio gratuito
Unendo senza ordinare
Considera i seguenti due array:
char arr1 [] = 'i', 'j', 'k', 'l', 'm';char arr2 [] = 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h';
Il primo ha 5 elementi e il secondo ha 8 elementi. Se gli elementi del secondo array sono in qualche modo montati sul retro del primo array, verrà formato un array di 13 elementi. Per raggiungere questo obiettivo senza utilizzare Store gratuito (memoria dinamica), è necessario creare prima un terzo array di 13 valori vuoti. Quindi i 5 valori del primo array verranno copiati, nelle prime 5 posizioni del terzo array. Gli 8 valori del secondo array saranno successivamente copiati sulle restanti 8 posizioni del terzo array. Il terzo array diventa l'array unito e desiderato. Il seguente programma illustra questo:
#includereUtilizzo dello spazio dei nomi std;
int main ()
char arr1 [] = 'i', 'j', 'k', 'l', 'm';
char arr2 [] = 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h';
char arr3 [13];
per (int i = 0; i< 5; i++)
arr3 [i] = arr1 [i];
per (int i = 5; i< 13; i++)
arr3 [i] = arr2 [i-5];
per (int i = 0; i< 13; i++)
cout<< arr3[i] << ";
cout<
L'output è:
I j k l m a b c d e f g hNota come l'indicizzazione è stata utilizzata nei loop per. Il problema con questo schema è che i primi due array sono diventati ridondanti. Ora stanno occupando inutilmente la memoria del computer. Senza negozio gratuito (memoria dinamica), gli array non possono essere rimossi dalla memoria fino a quando non escono dall'ambito. Per risolvere questo problema, usa il negozio gratuito - vedi sotto.
Il primo segmento di codice include la libreria iostream e dichiara l'uso dello spazio dei nomi standard per il resto del programma. Il resto del programma è nella funzione principale (). Le prime tre dichiarazioni nella funzione principale () dichiarano la prima, la seconda e la terza array. Il segmento di codice successivo è un per loop che copia tutti gli elementi dall'array più piccolo al terzo array. L'array più grande dei primi due, avrebbe potuto essere copiato per primo; non importa.
Il segmento di codice successivo utilizza il per loop per copiare l'array più grande sul retro dell'array più piccolo già nel terzo array. Il terzo array è l'array unita. La somma del numero di elementi nei primi due array dovrebbe essere uguale al numero di elementi nel terzo array. L'ultimo segmento di codice visualizza i valori nel terzo array.
Unendo con un po 'di smistamento
Durante l'inserimento di elementi nel terzo array, all'inizio, i primi elementi di entrambi gli array possono essere confrontati e il valore più piccolo inserito prima del primo valore dell'altro array. I secondi elementi di entrambi gli array possono essere confrontati in seguito e viene inserito il valore più piccolo inserito nel terzo array, prima del secondo valore dell'altro array. Il terzo elemento di entrambi i matrici può essere confrontato in seguito e il valore inferiore è inserito prima del terzo valore dell'altro array. Questa procedura continua fino a quando tutti gli elementi dell'array più corto non vengono inseriti insieme allo stesso numero di elementi dell'array più lungo. Il resto degli elementi dell'array più lungo può essere spinto nel terzo array nel loro ordine. Il seguente programma illustra questo:
#includereUtilizzo dello spazio dei nomi std;
int main ()
char arr1 [] = 'i', 'j', 'k', 'l', 'm';
char arr2 [] = 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h';
char arr3 [13];
per (int i = 0; i< 5; i++)
if (arr1 [i] < arr2[i])
arr3 [i*2] = arr1 [i];
arr3 [i*2+1] = arr2 [i];
altro
arr3 [i*2] = arr2 [i];
arr3 [i*2+1] = arr1 [i];
per (int i = 5; i< 8; i++)
arr3 [i+5] = arr2 [i];
per (int i = 0; i< 13; i++)
cout<< arr3[i] << ";
cout<
L'output è:
A i b j c k d l e m f g hNota l'aritmetica utilizzata negli indici.
Unendo gli array usando il negozio gratuito
Unendo senza ordinare
L'archivio gratuito è memoria allocato a un programma da utilizzare quando ha bisogno di memoria extra. Un array può essere creato ed eliminato in negozio gratuito con il nuovo operatore [] e l'operatore ELETE [], rispettivamente. I due programmi sopra verranno ripetuti di seguito. Il primo e il secondo array saranno creati dinamicamente in negozio gratuito e verranno eliminati dopo che il terzo array si è fatto. Il terzo array verrà creato nella memoria normale (area).
Il seguente programma lo illustra per la fusione senza ordinamento:
#includereUtilizzo dello spazio dei nomi std;
int main ()
char *arr1 = new char [5];
arr1 [0] = 'i'; arr1 [1] = 'j'; arr1 [2] = 'k'; arr1 [3] = 'l'; arr1 [4] = 'm';
char *arr2 = new char [8];
arr2 [0] = 'a'; arr2 [1] = 'b'; arr2 [2] = 'c'; arr2 [3] = 'd'; arr2 [4] = 'e'; arr2 [5] = 'f'; arr2 [6] = 'g'; arr2 [7] = 'H';
char arr3 [13];
//fusione
per (int i = 0; i< 5; i++)
arr3 [i] = arr1 [i];
per (int i = 5; i< 13; i++)
arr3 [i] = arr2 [i-5];
elimina [] arr1;
elimina [] arr2;
per (int i = 0; i< 13; i++)
cout<< arr3[i] << ";
cout<
L'output è:
I j k l m a b c d e f g hIl nome degli array nel negozio gratuito sono puntatori. Le posizioni degli elementi di ARR1 e ARR2 sono state eliminate dopo il loro uso nel programma. Il resto del codice è come un precedente.
Unendo con un po 'di smistamento
Il programma precedente con qualche smistamento viene ripetuto qui. Tuttavia, qui, i primi e i secondi array sono creati nel negozio gratuito. Sono eliminati dopo il loro uso. Il programma è:
#includereUtilizzo dello spazio dei nomi std;
int main ()
char *arr1 = new char [5];
arr1 [0] = 'i'; arr1 [1] = 'j'; arr1 [2] = 'k'; arr1 [3] = 'l'; arr1 [4] = 'm';
char *arr2 = new char [8];
arr2 [0] = 'a'; arr2 [1] = 'b'; arr2 [2] = 'c'; arr2 [3] = 'd'; arr2 [4] = 'e'; arr2 [5] = 'f'; arr2 [6] = 'g'; arr2 [7] = 'H';
char arr3 [13];
//fusione
per (int i = 0; i< 5; i++)
if (arr1 [i] < arr2[i])
arr3 [i*2] = arr1 [i];
arr3 [i*2+1] = arr2 [i];
altro
arr3 [i*2] = arr2 [i];
arr3 [i*2+1] = arr1 [i];
per (int i = 5; i< 8; i++)
arr3 [i+5] = arr2 [i];
elimina [] arr1;
elimina [] arr2;
per (int i = 0; i< 13; i++)
cout<< arr3[i] << ";
cout<
L'output è:
A i b j c k d l e m f g hConclusione
La fusione degli array è in realtà una cosa semplice. In definitiva, adatta a un array sul retro dell'altro array e hai unito i due array. I problemi che i programmatori devono affrontare con gli array di fusione, non hanno a che fare con l'adattamento di un array sul retro di un altro array. Hanno a che fare con la cancellazione dei due array precedenti e/o l'ordinamento dell'array unita. Gli array devono essere dello stesso tipo, per essere uniti.
Se uno dei primi due array non sarà più necessario dopo la fusione, dovrebbe essere creato dinamicamente in negozio gratuito, quindi essere eliminato dopo l'uso, per la memoria libera. L'array unita può anche essere creato in negozio gratuito, ma ciò non è necessario.
L'array unita può essere ordinato in misura diversa. L'ordinamento completo è un intero argomento nella programmazione del computer. L'ordinamento completo è di diversi schemi nella programmazione di computer. C'è uno schema chiamato Merge-Sort. Questo schema fa la fusione e l'ordinamento allo stesso tempo. Tuttavia, lo schema più popolare sembra essere QuickSort.