Salve a tutti!!Ho un pò di problemi con questo esercizio, in cui si deve inserire un vettore da tastiera e si dovranno scrivere le funzioni seguenti:
- Funzione di creazione ed inizializzazione:
dyn_array * create_dyn_array(int size)
Tale funzione prende in input la dimensione predefinita iniziale del vettore size e restituisce il puntatore alla struttura allocata.
La funzione deve:
allocare la zona di memoria per la struttura dyn_array
allocare il vettore di interi di interi di dimensione size
inizializzare i valori di length a size e next_index a 0.
- Funzione di aggiunta di un elemento:
void add_elem(dyn_array *da, int value, int size)
Tale funzione aggiunge un elemento con valore value in posizine da->next_index al vettore da->V
Se il vettore e' pieno, cioe' prima dell'inserimento da->next_index == da->length, la funzione deve:
allocare un nuovo vettore V' di dimensione da->length + size
copiare i valori di V in V'
inserire il nuovo elemento in V'
liberare la memoria occupata da da->V
Sostituire da->V con V'
Aggiornare da->next_index e da->length in modo opportuno
- Funzione di rimozione di un elemento in una data posizione:
void remove_elem_at(dyn_array *da, int index, int size)
La funzione rimuove l'elemento in posizine index dal vettore da->V. Se index > da->next_index la funzione non fa nulla, altrimenti rimuove l'elemento in posizione index spostando verso sinistra tutti gli altri di una posizione.
Se il vettore risultante ha una zona vuota di dimensione maggiore di size, cioe' se (da->next_index <= (da->length - size)), la funzione deve:
allocare un nuovo vettore V' di dimensione da->length - size
copiare i valori di V in V'
liberare la memoria occupata da da->V
Sostituire da->V con V'
Aggiornare da->next_index e da->length in modo opportuno
- Funzione di rimozione di un elemento in una data posizione:
void remove_elem_at(dyn_array *da, int index, int size)
La funzione rimuove l'elemento in posizine index dal vettore da->V. Se index > da->next_index la funzione non fa nulla, altrimenti rimuove l'elemento in posizione index spostando verso sinistra tutti gli altri di una posizione.
Se il vettore risultante ha una zona vuota di dimensione maggiore di size, cioe' se (da->next_index <= (da->length - size)), la funzione deve:
allocare un nuovo vettore V' di dimensione da->length - size
copiare i valori di V in V'
liberare la memoria occupata da da->V
Sostituire da->V con V'
Aggiornare da->next_index e da->length in modo opportuno
- Funzione di rimozione di tutti gli elementi con un certo valore:
void remove_value(dyn_array *da, int value, int size)
La funzione rimuove dal vettore da->V tutti gli elementi con valore value Gli elementi rimanenti devono essere spostati verso sinistra cosi' da non lasciare posizioni vuote.
Se il vettore risultante ha una zona vuota di dimensione maggiore di size, cioe' se (da->next_index <= (da->length - size)), la funzione deve:
trovare il piu' piccolo valore k tale che k*size > da->next_index
allocare un nuovo vettore V' di dimensione k*size
copiare i valori di V in V'
liberare la memoria occupata da da->V
Sostituire da->V con V'
Aggiornare da->next_index e da->length in modo opportuno
- Funzione di ordinamento:
void sort_dyn_array(dyn_array *da)
La funzione deve ordinare il vettore da->V in modo CRESCENTE. Le sue dimensioni rimangono invariate.
codice:#include <stdio.h> #include <stdlib.h> //dimensione iniziale del vettore dinamico - NON MODIFICARE #define SIZE 10 /* definizione della struttura del vettore dinamico - NON MODIFICARE int *V: Vettore di interi int length: lunghezza attuale del vettore di interi int next_index: prossimo elemento su cui scrivere, se il vettore non e' pieno next_index < length, se e' pieno next_index = length. */ typedef struct dyn_array{ int *V; int length; int next_index; } dyn_array; //prototipi delle funzioni di utilita' - NON MODIFICARE dyn_array * create_dyn_array(int size); void remove_elem_at(dyn_array *da, int index, int size); void remove_value(dyn_array *da, int value, int size); void add_elem(dyn_array *da, int value, int size); void sort_dyn_array(dyn_array *da); void print_dyn_array(dyn_array * da); //main, NON MODIFICARE int main(){ int x = 0; dyn_array *da = create_dyn_array(SIZE); scanf("%d",&x); while (x != -1){ add_elem(da,x,SIZE); scanf("%d",&x); } print_dyn_array(da); int i, top = da->next_index/2; for (i = 0; i < top; i++){ remove_elem_at(da, i, SIZE); } print_dyn_array(da); remove_value(da, 64, SIZE); print_dyn_array(da); sort_dyn_array(da); print_dyn_array(da); } //Funzione di stampa - NON MODIFICARE void print_dyn_array(dyn_array * da){ int i; printf("%d\n",da->length); printf("%d\n",da->next_index); for (i = 0; i < da->next_index; i++){ printf("%d ",(da->V)[i]); } for (i = da->next_index; i < da->length; i++){ printf("X "); } printf("\n"); } /*funzione di creazione ed inizializzazione La funzione prende in input la dimensione predefinita iniziale del vettore size e restituisce il puntatore alla struttura allocata. La funzione deve: - allocare la zona di memoria per la struttura dyn_array - allocare il vettore di interi di interi di dimensione size - inizializzare i valori di length a size e next_index a 0. */ dyn_array * create_dyn_array(int size){ dyn_array*da; da = (dyn_array*)malloc(sizeof(dyn_array)); da -> V = (int*)malloc(sizeof(int)*size); da -> length = size; da -> next_index = 0; return da; } /* Funzione di aggiunta di un elemento La funzione aggiunge un elemento con valore value in posizine da->next_index al vettore da->V Se il vettore e' pieno la funzione deve: - allocare un nuovo vettore V' di dimensione da->length + size - copiare i valori di V in V' - inserire il nuovo elemento in V' - liberare la memoria occupata da da->V - Sostituire da->V con V' - Aggiornare da->next_index e da->length in modo opportuno */ void add_elem(dyn_array *da, int value, int size){ if(da -> next_index == da -> length){ int *V1; int i; V1 = (int *)malloc(sizeof(int)*(da -> length + size)); for(i=0; i<da->length; i++){ V1[i]=da->V[i]; } V1[da->length]= value; free( da -> V ); da -> V = V1; da -> next_index = da ->next_index +1; da -> length = da -> length + size; } else { da -> V[da->next_index] = value; da -> next_index = da -> next_index +1; } } /* Funzione di rimozione di un elemento in una data posizione La funzione rimuove l'elemento in posizine index dal vettore da->V. Se index > da->next_index la funzione non fa nulla, altrimenti rimuove l'elemento in posizione index spostando verso sinistra tutti gli altri di una posizione. Se il vettore risultante ha una zona vuota di dimensione maggiore di size, cioe' se (da->next_index <= (da->length - size)), la funzione deve: - allocare un nuovo vettore V' di dimensione da->length - size - copiare i valori di V in V' - liberare la memoria occupata da da->V - Sostituire da->V con V' - Aggiornare da->next_index e da->length in modo opportuno */ void remove_elem_at(dyn_array *da, int index, int size){ int i; if(index > da -> next_index) return; for(i=index; i<da->length-1; i++){ da->V[i] = da->V[i+1]; } --(da-> next_index); if(da->next_index <= (da->length-size)){ int * V1, *V; V1=(int *)malloc(sizeof(int)*(da->length-size)); for(i=0; i<da->next_index; i++){ V1[i]=V[i]; } free(da->V); da -> V = V1; da -> length = - size; } } /* Funzione di rimozione di tutti gli elementi con un certo valore La funzione rimuove dal vettore da->V tutti gli elementi con valore value Gli elementi rimanenti devono essere spostati verso sinistra cosi' da non lasciare posizioni vuote. Se il vettore risultante ha una zona vuota di dimensione maggiore di size, cioe' se (da->next_index <= (da->length - size)), la funzione deve: - trovare il piu' piccolo valore k tale che k*size > da->next_index - allocare un nuovo vettore V' di dimensione k*size - copiare i valori di V in V' - liberare la memoria occupata da da->V - Sostituire da->V con V' - Aggiornare da->next_index e da->length in modo opportuno */ void remove_value(dyn_array *da, int value, int size){ int i,j,k=0; for(i=0;i<da->length-1;i++){ for(j=i+1;j<da->next_index-1;j++) if(da->V[i]== value && !k){ k=1; j=i+1;} if(k){ while(k*size<da->next_index) k++; da -> V[i] = da -> V[j]; if(da->V[i] == value) da->next_index = da->next_index-1;} int *V1; V1=(int *)malloc(sizeof(int) *(da->length-size)); for(i = 0; i < da -> next_index; i++){ V1[i]=da->V[i]; } free(da->V); da -> V = V1; da -> length = da -> length - size; } } /* Funzione di ordinamento La funzione deve ordinare il vettore da->V in modo CRESCENTE. Le sue dimensioni rimangono invariate. Si puo' implementare con un qualsiasi algoritmo. */ void sort_dyn_array(dyn_array *da){ int i,j,x; for(j=1; j<da->next_index;j++){ x = da->V[j]; i = j-1; while((i > 0) && (da->V[j] > x)){ da-> V[i+1] = da-> V[i]; i = i-1; } da-> V[i+1] = x; } }
Rispondi quotando