Esercizio frequenza occorrenza di elemento vettore

di il
1 risposte

Esercizio frequenza occorrenza di elemento vettore

Sto svolgendo quest'esercizio:
"Siano dati in ingresso il riempimento e gli elementi di un vettore di interi V. Scrivere un programma che identifichi e memorizzi in un’apposita struttura dati gli elementi distinti presenti nel vettore e la loro frequenza di occorrenza. Si provveda poi a ordinare gli elementi del vettore in modo crescente in base alla loro frequenza di occorrenza. Nel caso esistano due o più elementi aventi la stessa frequenza di occorrenza, si elimini il minore di tali elementi. Stampare infine il vettore V cosi ottenuto."

Sto a buon punto, ho creato una struct fatta delle due parti "elemento_distinto" e "frequenza_occorrenza". Ho chiesto di mostrarmi gli elementi distinti trovati del vettore e non capisco perchè li mostra ordinati in modo crescente e non nell'ordine di memorizzazione. Gli elementi distinti trovati sono corretti solo che vengono mostrati in ordine crescente senza la mia volontà. Come mai?

1 Risposte

  • Re: Esercizio frequenza occorrenza di elemento vettore

    La risposta alla domanda precedente è banale.
    Ho risolto l'esercizio così, solo che non capisco come eliminare l'elemento minore della coppia avente la stessa frequenza.
    
    #include<iostream>
    #include<stdlib.h>
    #include<math.h>
    using namespace std;
    void ivettore(int dim,int v[])
    {
        for(int i=0;i<dim;i++)
        {
            cout<<"\nInserisci l'elemento "<<i+1<<" ";
            cin>>v[i];
        }
    }
    void ovettore(int dim,int v[])
    {
        for(int i=0;i<dim;i++)
        {
            cout<<"  "<<v[i];
        }
    }
    int cerca_minimo(int dim,int v[])
    {
        int min=v[0];
        for(int i=1;i<dim;i++)
        {
            if(min>v[i])
                min=v[i];
        }
        return min;
    }
    int cerca_massimo(int dim,int v[])
    {
        int max=v[0];
        for(int i=1;i<dim;i++)
        {
            if(max<v[i])
                max=v[i];
        }
        return max;
    }
    int posizione_minimo(int dim,int v[])
    {
        int min=v[0];
        int  posmin=0;
        for(int i=1;i<dim;i++)
        {
            if(min>v[i])
            {
               min=v[i];
               posmin=i;
            }
        }
        return posmin+1;
    }
    void elimina_k_elementi(int k,int pos,int dim,int v[])
    {
        int j=pos-1;
        for(int i=j;i<dim-k;i++)
        {
            v[i]=v[i+k];
        }
        
    }
    
    int main()
    {
        int dim;
        int v[100];
        cout<<"Dimensione v ";
        cin>>dim;
        ivettore(dim,v);
        cout<<"v= ";
        ovettore(dim,v);
       struct analisi_vettore
        {
            int elemento_distinto;
            int frequenza_occorrenza;
        };
        analisi_vettore vettore[100];
        int m=0; //indica la componente finale della struttura dati che si impegna 
        int n=1;
        vettore[m].elemento_distinto=cerca_minimo(dim,v);
        vettore[m].frequenza_occorrenza=n;
        elimina_k_elementi(1,posizione_minimo(dim,v),dim,v);
        dim=dim-1;
        while(dim!=0)
        {
            if(cerca_minimo(dim,v)==vettore[m].elemento_distinto)
            {
                n++;
                vettore[m].frequenza_occorrenza=n;
            }
            else
            {
                m++;
                vettore[m].elemento_distinto=cerca_minimo(dim,v);
                n=1;
                vettore[m].frequenza_occorrenza=n;
            }
            elimina_k_elementi(1,posizione_minimo(dim,v),dim,v);
            dim=dim-1;
        }
        cout<<"\n";
        for(int i=0;i<=m;i++)
        {
            cout<<"\nC'è l'elemento distinto "<<vettore[i].elemento_distinto<<" con frequenza di occorrenza pari a "<<vettore[i].frequenza_occorrenza;
        }
        //definisco un vettore in cui memorizzo le varie frequenze di occorrenza
        const int emme=m+1;
        int M=m+1;
        int vett_freq[emme];
        for(int i=0;i<emme;i++)
        {
            vett_freq[i]=vettore[i].frequenza_occorrenza;
        }
        //definisco un vettore in cui memorizzo gli elementi distinti
        int elem_dist[emme];
        for(int i=0;i<emme;i++)
        {
            elem_dist[i]=vettore[i].elemento_distinto;
        }
        //creo una copia del vettore precedente da sfruttare successivamente
        int elem_dist1[emme];
        for(int i=0;i<emme;i++)
        {
            elem_dist1[i]=elem_dist[i];
        }
        //definisco un vettore che contiene le posizioni (a partire da 0) degli elementi del vettore delle frequenze di occorrenza ordinate in modo crescente
        int posFreq_ordinata[emme];
        for(int i=0;i<emme;i++)
        {
            posFreq_ordinata[i]=posizione_minimo(M,vett_freq)-1; //-1 perchè è la posizione vista dal calcolatore (quindi parte da 0)
            vett_freq[posizione_minimo(M,vett_freq)-1]=cerca_massimo(M,vett_freq)+1;
        }
        cout<<"\n";
        ovettore(emme,posFreq_ordinata);
        
        //ordino quindi il vettore degli elementi distinti in base alla frequenza di occorrenza crescente
        for(int i=0;i<emme;i++)
        {
            elem_dist[i]=elem_dist1[posFreq_ordinata[i]];
        }
        cout<<"\nIl vettore degli elementi distinti ordinato in base alla frequenza di occorrenza crescente è\n";
        ovettore(emme,elem_dist);
    }
    
    
Devi accedere o registrarti per scrivere nel forum
1 risposte