[C++] unione di due array in un terzo

[vfabrisv94]

Salve a tutti, dovrei scrivere un programma che unisce il vettore V[n] (ordinato in modo crescente)ed il vettore W[m](ordinato in modo decrescente) in un terzo vettore (ordinato in modo crescente ), ecco come ho fatto io:

Codice: Seleziona tutto

#include<iostream>
using namespace std;
const int dim=100;

void carica_vettore(int vett[dim],int *punt_n){

    cout<<"Quanti elementi vuoi inserire nel vettore?"<<endl;
    cin>>*punt_n;
    cout<<endl<<endl;

    cout<<"Inserisci gli elementi nel vettore"<<endl;
    for(int i=0; i<*punt_n; i++)
    {
        cout<<"Inserisci il "<<i+1<<" elemento: ";
        cin>>vett[i];
    }
    cout<<endl<<endl;
}

void stampa_vettore(int vett[dim], int *punt_n){


    for(int i=0; i<*punt_n; i++)
    {
        cout<<vett[i]<<"\t";
    }
    cout<<endl;
}

void ordina_crescente(int vett[dim], int *p){

int temp;

for(int i=0; i<*p; i++)
{
    for(int j=0; j<*p; j++)
    {
        if(vett[j]>vett[i])
        {
            temp=vett[j];
            vett[j]=vett[i];
            vett[i]=temp;
        }
    }
}

}

void ordina_decrescente(int vett[dim], int *p){


int temp;

for(int i=0; i<*p; i++)
{
    for(int j=0; j<*p; j++)
    {
        if(vett[j]<vett[i])
        {
            temp=vett[j];
            vett[j]=vett[i];
            vett[i]=temp;
        }
    }
}


}

void funcVettT(int v[dim], int w[dim], int t[dim], int *n, int *m){


    for(int i=0; i<*n; i++)
    {
        t[i]=v[i]+w[i];
    }

}

int main(){

int v[dim], w[dim], t[dim];
int n, m;

carica_vettore(v, &n);
carica_vettore(w, &m);
ordina_crescente(v, &n);
ordina_decrescente(w, &m);

cout<<"Ecco l'array 'v' ordinato in modo crescente: "<<endl;
stampa_vettore(v,&n);
cout<<endl;

cout<<"Ecco l'array 'w' ordinato in modo decrescente: "<<endl;
stampa_vettore(w,&m);
cout<<endl;

funcVettT(v,w,t,&n,&m);
ordina_crescente(t,&n);
cout<<"Ecco l'array 't' ordinato in modo decrescente: "<<endl;
stampa_vettore(t,&n);

Non riesco ad unirli si sommano e basta. Potete aiutarmi ?

[1001001]

E certo che si sommano, glielo hai detto tu!

Codice: Seleziona tutto

    for(int i=0; i<*n; i++)
    {
        t[i]=v[i]+w[i];
    }

Devi scorrere entrambi i vettori (uno da inizio a fine e l'altro da fine a inizio) scegliendo ogni volta il giusto elemento sfruttando il fatto che sono già ordinati

[SuperStep]

l'algoritmo di ordinamento è molto scadente, in questo caso sarebbe meglio utilizzare la parte merge del merge-sort.

abbiamo due array
A di size a;
B di size b;

Il vettore ordinato C sarà di size (a+b).

Supponendo il caso in cui sia A che B sono ordinati (rispettivamente in crescente e decrescente come nelle specifiche) ,
prendiamo due puntatori a_ptr = &A[0] e b_ptr = &B[b-1].

A questo punto facciamo questo confronto: quale dei due fra a_ptr e b_ptr è minore? se è a_ptr C[0] diventa a_ptr e a_ptr viene incrementato alla prossima posizione. Nel caso in cui sia b_ptr minore di a_ptr, C[0] diventa b_ptr e b_ptr viene decrementato alla prossima posizione.

Per ogni inserimento utilizziamo il un terzo puntatore c_ptr che inizialmente punta a C[0], questo viene incrementato per ogni assegnazione. (quindi sopra non sarà C[0], ma il riferimento (c_ptr)) a_ptr non deve incrementare se punta già all'ultimo elemento di A e b_ptr non deve decrementare se punta già al primo elemento di B. Nei casi specificati ti serve un booleano per specificare che (A o B) sono stati interamente consumati, di conseguenza puoi finire di scaricare l'array (A o B da terminare) su C in maniera progressiva.

Puoi cercare merge-sort per una spiegazione più esaustiva.

[vfabrisv94]

Grazie . Però il mio problema principale e che io non unisco i due array nel terzo, ma li sommo.

[SuperStep]

infatti devi allocare un terzo array di dimensione (a + b).

e devi inserire gli elementi in questo terzo array (C) come ti ho spiegato.

prendo i 3 array

Codice: Seleziona tutto

A[a];
B[b];
C[a + b];

prendi i tre indici

Codice: Seleziona tutto

a_ptr = &A[0]
b_ptr = &B[b - 1]
c_ptr = &C[0]

poi fai in questo modo

Codice: Seleziona tutto

while(true) {
//Metto gli elementi a seconda della posizione
if(*a_ptr < *b_ptr){
    *c_ptr = *a_ptr;
    a_ptr++ 
}
else {
    *c_ptr++ = *b_ptr;
    b_ptr--;
}

c_ptr++;

if(a_ptr > &A[a-1]){
    //a_ptr ha superato il limite di A. Quindi non ci sono piu' elementi in A
    // scarico il restante di B
   while(b_ptr != &B[0]){
        *c_ptr = *b_ptr;
        c_ptr++;
        b_ptr--;
    }
    break;
}

if(b_ptr < &B[0]){
    //b_ptr ha superato il limite di B. Quindi non ci sono piu' elementi in B
    //scarico il restante di A
    while(a_ptr != &A[a-1]){
        *c_ptr = *a_ptr;
        c_ptr++;
        a_ptr++;
    }
    break;
}
}

non l'ho provato ma la logica dovrebbe essere giusta.