//LIBRERIA DI FUNZIONI UTILI

// Conversione numero binarioNAT (da un array) a decimale

int binTodec(int daConv[]){

int i, ris;
for(i=0 ; i<BIT ; i++){ // definire BIT con il numero di bit
del numero binarioNAT
ris = ris + (daConv[i]*pow(2,i)); //N.B. necessario
includere la libreria <math.h> o scrivere una funzione potenza;
}
return ris;
}
//Conversione numero decimale in binarioNAT (in un array)
void decTobin(int daConv, int conv[]){ // necessario definire nella
funzione chiamante un array, di grandezza BIT, in cui salvare ris.
int i, ris;
for(i=BIT-1 ; i<=0 ; i--){
conv[i]= daConv % 2;
daConv=daConv / 2;
}
}

//

Potenza - N.B. tale funzione esiste nella lib. <math.h>

int pow(int base, int exp){

int ris=1, i=0;
for(i=0; i<exp ; i++){
ris = ris*base;
}
return ris;
}
//BubbleSort - Ordina gli elementi di un vettore in ordine crescente
void bubblesort(int daOrd[]) {
int i,k;
int temp;
for(i = 0; i<MAX-1; i++) { // con MAX si intende la grandezza del vettore
da ordinare
for(k = 0; k<MAX-1-i; k++) {
if(daOrd[k] > daOrd[k+1]) {

temp = daOrd[k];
daOrd[k] = daOrd[k+1];
daOrd[k+1] = temp;
}
}
}
}
// Swap - scambia i valori di due variabili
void swap(int *a, int *b){ // nell'invocare la funzione necessario
mettere '&' prima dei parametri (passare indirizzi)
int temp;
temp = *a;
*a = *b;
*b = temp;
}
//Verifica se un numero primo
int verifica_primo(int daVer){
int primo=1, n;
for (n=2;n<=daVer/2 && primo;n++)
if ((daVer % n)==0)
primo=0;
return primo;

//resistuisce 1 se il numero primo, 0 altrimenti

// Scansione di un array
void getArray(int VETT[]){
int i;
for(i=0 ; i<MAX ; i++){
printf("Inserire elemento %d del vettore: ", i+1);
scanf("%d", &VETT[i]);
}

// Scansione matrice
void getMatr(int MATR[][MAX2]){
grande MAX1 x MAX2

//la matrice parametro deve essere

int i, j;
for(i=0 ; i<MAX1 ; i++){
for(j=0 ; j<MAX2 ; j++){
printf("Inserire elemento [%d,%d] della matrice: ", i, j);
scanf("%d", &MATR[i][j]);
}
}
}
// Stampa array
void printArray(int VETT[ ]){
int i;
for(i=0 ; i<MAX ; i++){
printf("%d ", VETT[i]);
}}
// Stampa matrice
void printMatr(int MATR[][MAX2]){
int i, j;
for(i=0 ; i<MAX1 ; i++){
printf("\n");
for(j=0 ; j<MAX2 ; j++)
printf("%d\t ", MATR[i][j]); }
}
// Copia una matrice in un array ordinatamente
void matrToarray( int MATR[][N], int VETT[]){ //N.B. la matrice parametro
ha dimensioni [N][N] e l'array dimensione [N*N]
int i, j, x;
for(i=0; i<N ; i++){
for(j=0 ; j<N ; j++){
x=((i*N)+j);
VETT[ x ] = MATR[i][j] ;
}}}

MEMORIA DINAMICA
Le funzioni sottostanti agiscono su strutture dati di tipo LISTA, composte da
nodi cos definiti:
typedef struct El {
tipoDato dato;
struct El *prox;}

nodo;

// Creare un singolo nodo (dal main o da una funzione)

nodo *newNd;
newNd = (nodo *)malloc(sizeof(nodo)); // alloca nello heap la memoria
newNd->dato = quello che vuoi ; // inizializza il dato con quello che vuoi
newNd->prox = NULL; // inizializza il puntatore al nodo successivo a NULL

// Cancella TUTTI i nodi aventi un dato, restituisce la testa della lista

nodo* eliminaDato(nodo* testa, tipoDato daCanc){
nodo* tempRef, nuovaTesta;
nuovaTesta = testa;
while(testa->dato == daCanc && testa != NULL){
tempRef = testa;
testa = testa->prox;
free(tempRef);
nuovaTesta = testa;
} /* Toglie i nodi in testa (aventi il dato da eliminare) finch
testa punta al primo nodo da non eliminare*/
while( testa != NULL){
if(testa->prox->dato == daCanc){
tempRef = testa->prox;
testa->prox = tempRef->prox;
free(tempRef); } /*elimina il nodo successivo a testa se
contiene il dato da eliminare */
testa = testa->prox; }
return nuovaTesta; /*restituisce il puntatore alla testa della lista*/
}

// Stampa a video una lista

void stampaLista( nodo* lista ) {
if ( lista==NULL )
printf(" end- \n");
else {
printf(" %d\n --> ", lista>dato);
stampaLista( lista>prox );
}
}
// Distrugge una lista intera
void DistruggiLista( nodo* lista ) {
nodo* tempRef;
while( lista != NULL ) {
tempRef = lista>prox;
free( lista );
lista = tempRef;
} }
// Crea una lista lunga quanto ti pare inserendo in coda
nodo* creaLista(){
nodo *testa, *elem, *veraTesta;
int risp;
printf("Inserire il primo elemento: ");
testa = (nodo *) malloc(sizeof(nodo));
scanf("%d", &testa->dato);
testa->prox=NULL;
veraTesta=testa;
while(1){
printf("Inserire un elemento? (1/0): ");
scanf("%d", &risp);
fflush(stdin);
if(risp == 1){
elem = (nodo *) malloc(sizeof(nodo));
testa->prox = elem;
testa = elem;
printf("Inserire l'elemento: ");
scanf("%d", &testa->dato);
}
if(risp == 0){
elem->prox=NULL;
break;
}
}
return veraTesta;
}

// BubbleSort, mette in ordine crescente una lista di interi

nodo* bubble_sort(nodo *primo) {
nodo *p, *ultimo;
int flag, aux;
ultimo = NULL;
flag = 1;
while(flag == 1) {
p = primo;
flag = 0;
while(p->next != ultimo) {
if (p->info > (p->next)->info) {
aux = p->info;
p->info = (p->next)->info;
(p->next)->info = aux;
flag = 1;
}
p = p->next;
}
ultimo = p;
}
}

return(primo);