Esercizio n. 16 Un bucket sort incomincia dichia

/* ============================================================================
Esercizio n. 16
Un bucket sort incomincia dichiarando un vettore unidimensionale di interi
positivi,
quello che dovrà essere ordinato, e una matrice di interi con le righe
indicizzate da 0 a
9 e le colonne da 0 a n-1, dove n è il numero dei valori presenti nel vettore che
dovrà
essere ordinato.
Ogni riga della matrice è detta bucket (secchio).
L’algoritmo di ordinamento è il seguente:
Scorrete il vettore unidimensionale e sistemate ognuno dei suoi valori in una
riga della
matrice, basandovi sulla cifra delle unità.
Per esempio:
dati 3 numeri 97,3 e 100, il 97 sarà sistemato nella riga 7, il 3 sarà inserito
nella riga 3 e
il 100 sarà posto nella riga 0.
Scorrete la matrice e riportate i valori nel vettore originario. Nel vettore
unidimensionale
il nuovo ordine dei suddetti valori sarà: 100,3,97.
Ripetete questo processo per ogni successiva posizione delle cifre (decine,
centinaia,
migliaia, ecc.) e fermatevi quando sarà stata elaborata la cifra più
significativa del
numero più grande.
Scrivere una funzione in grado di ricevere come parametro un vettore di numeri
interi e
la sua dimensione e restituire il vettore ordinato utilizzando l’algoritmo di
bucket sort.
============================================================================== */
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
int calcola_cifra_n(int numero, int n);
void func_ordinamento(int vettore[],int dim);
main()
{
int i,n,n_cifre;
int a[100];
//inserisci i numeri interi nel vettore a
printf("Quanti valori da inserire ? : ");
scanf("%d",&n);
for (i=0;i<=n-1;i++) {
n_cifre=0;
printf("Inserisci il valore nella cella %d : ",i);
scanf("%d",&a[i]);
// effettuiamo il controllo dei numeri affinchè questi siano solo
positivi
if (a[i]<0){
puts("\n-------------------------------------------------------");
puts("ATTENZIONE : il programma accetta solo interi positivi.");
puts("ORA SI USCIRA' DAL PROGRAMMA.");
puts("-------------------------------------------------------");
abort();
}
}
func_ordinamento(a,n); // richiamiamo la funzione ordinamento
// stampiamo il vettore finale ordinato
for (i=0;i<=n-1;i++)
printf("Ordinamento finale: %10d\n",a[i]);
}
/* ===================================================================== */
/* segue la funzione ordinamento "BUCKET SORT"
/* ===================================================================== */
void func_ordinamento(int a[],int dim)
{
int i,r,n_cifre,conta,c,resto, max;
int j,n_cifre_max;
int b[10][100];
// determina il valore più grande
max=0;
for (i=0;i<=dim-1;i++)
if (a[i]>max)
max=a[i];
// determina il numero di cifre di max
// questo ci servirà per determinare il ciclo di volte da eseguire
l'ordinamento
i=1;
while (i<=10) {
j=pow(10,i);
if ((max%j)==max){
n_cifre_max=i;
break; // un break ogni tanto lo possiamo anche mettere
}
i++;
}
printf("\n");
/* =================================================================== */
/* qui inizia il ciclo di ordiamento
/* =================================================================== */
for (j=1;j<=n_cifre_max;j++){
// resetta vettore
for (r=0;r<=9;r++) // r=righe
for (c=0;c<=dim-1;c++) // c=colonne
b[r][c]=-1;
for (i=0;i<=dim-1;i++){
resto=calcola_cifra_n(a[i],j); // determina l'ennesima cifra
if (resto>=0)
b[resto][i]=a[i];
}
// scorri il vettore bidimensionale e reinserisci i numeri nel vettore
iniziale
conta=0;
for (r=0;r<=9;r++) // righe del vettore bidimensionale
for (c=0;c<=dim-1;c++) // colonne del vettore bidimensionale
if (b[r][c]!=-1){
a[conta]=b[r][c];
conta+=1;
// contatore che fa da indice al vettore
monodimensionale mano a mano
// che trova valori da inserire.
}
}
/* ==================================================================== */
/* e qui finisce il ciclo
/* ==================================================================== */
}
// la funzione seguente determina il valore dell'ennesima cifra
int calcola_cifra_n(int numero,int n)
{
int c,resto,div,ennesima_cifra;
c=pow(10,n);
resto=numero%c;
div=resto/pow(10,n-1);
if (resto==numero)
if (div>0)
ennesima_cifra=div;
else
ennesima_cifra=0; // superato il numero di cifre del numero
else
ennesima_cifra=div;
return ennesima_cifra;
}