#include <stdio.h>
#include <stdlib.h>

Liste

struct elemento{
int info;
struct elemento *next;
};
typedef struct elemento ElementoDiLista;
typedef ElementoDiLista *ListaDiElementi;

void InserisciTestaLista(ListaDiElementi* lista, int elem){
ListaDiElementi aux;
aux=malloc(sizeof(ElementoDiLista));
aux->info=elem;
aux->next=*lista;
*lista=aux;
}

void StampaLista(ListaDiElementi lis){
while (lis != NULL){
printf ("%d->", lis->info);
lis = lis->next;
}
printf("//");
}

void CancellaPrimo(ListaDiElementi* lista){
ListaDiElementi aux;
if(*lista!=NULL){
aux=*lista;
*lista=(*lista)->next;
free(aux);
}
}

void InserimentoInCoda(ListaDiElementi* lista, int v){
ListaDiElementi ultimo, aux;
aux=malloc(sizeof(ElementoDiLista));
aux->info=v;
aux->next=NULL;
if (*lista==NULL) {
*lista=aux;
} else {
ultimo=*lista;
while (ultimo->next!=NULL) {
ultimo=ultimo->next;
}
ultimo->next=aux;
}
}

void CancellaElementoRic(ListaDiElementi* lista, int v){
if (*lista!=NULL){
if((*lista)->info==v){
CancellaPrimo(lista);
} else {
CancellaElementoRic(&((*lista)->next),v);
}
}
}

void ControllaOrdine(ListaDiElementi* lista, boolean* crescente){
if((*lista)->next==NULL){
*crescente=True;
} else {
ListaDiElementi succ=(*lista)->next;
if ((*lista)->info>=succ->info){
*crescente=False;
} else {
*lista=(*lista)->next;
ControllaOrdine(lista, crescente);
}
}
}

void menounopari(ListaDiElementi* lista) {
if (*lista!=NULL) {
if ((*lista)->info%2==0) {
InserisciTesta(lista, -1);
menounopari(&(((*lista)->next)->next));
} else {
menounopari(&((*lista)->next));
}
}
}

void terzalista(ListaDiElementi* lista1, ListaDiElementi* lista2, ListaDiElementi* lista3) {
if (*lista1!=NULL) {
if (*lista2!=NULL) {
if ((*lista1)->info>(*lista2)->info) {
ListaDiElementi primo=*lista2;
*lista2=(*lista2)->next;
primo->next=NULL;
*lista3=primo;
} else {
ListaDiElementi primo=*lista1;
*lista1=(*lista1)->next;
primo->next=NULL;
*lista3=primo;
}
terzalista(lista1, lista2 , &((*lista3)->next));
} else *lista3=*lista1;
} else {
if (*lista2!=NULL) {
*lista3=*lista2;
} else {
*lista3=NULL;
}
}
}

void InserimentoDecrordinato(ListaDiElementi* lista, int elem){
if (*lista==NULL) {
InserisciTesta(lista, elem);
} else {
if ((*lista)->info>=elem) {
InserimentoDecrordinato(&((*lista)->next), elem);
} else {
InserisciTesta(lista, elem);
}
}
}

void Riempibuchi(ListaDiElementi* lista) {
int diff;
if (*lista!=NULL) {
if ((*lista)->next!=NULL) {
if (((*lista)->info)>(((*lista)->next)->info)) {
diff=((*lista)->info)-(((*lista)->next)->info)-1;
if (diff>0) {
InserisciTesta(&((*lista)->next), (((*lista)->next)->info)+diff);
Riempibuchi(lista);
}
}
Riempibuchi(&((*lista)->next));
}
}
}

void CalcoloSomma(ListaDiElementi* lista, int* somma) {
if ((*lista)!=NULL) {
*somma+=(*lista)->info;
if ((*lista)->next!=NULL) {
CalcoloSomma(&((*lista)->next), somma);
}
}
}

void NumeroElementi(ListaDiElementi* lista, int v, int* num) {
if ((*lista)!=NULL) {
if ((*lista)->info>v) {
*num+=1;
}
if ((*lista)->next!=NULL) {
NumeroElementi(&((*lista)->next), v, num);
}
}
}

Alberi

struct NodoAlberoBinario{
int label;
struct NodoAlberoBinario *left;
struct NodoAlberoBinario *right;
};
typedef struct NodoAlberoBinario NodoAlbero;
typedef NodoAlbero* AlberoBinario;

void inserisciSimple(AlberoBinario *alb, int value, int depth){
if (*alb == NULL) {
AlberoBinario aux = malloc(sizeof(NodoAlbero));
aux->left = NULL;
aux->right = NULL;
aux->label = value;
*alb = aux;
} else {
if ((((*alb)->label) + value + depth) % 2 == 0){
inserisciSimple(&((*alb)->left), value, depth+1);
} else {
inserisciSimple(&((*alb)->right), value, depth+1);
}
}
}

void stampaAlbero(AlberoBinario alb){
if (alb == NULL){
printf("()");
} else {
printf("( %d ", alb -> label);
stampaAlbero(alb->left);
printf(" ");
stampaAlbero(alb->right);
printf(" )");
}
}

int member (AlberoBinario bt, int elem){
int ris=0;
if (bt!=NULL){
if (bt->label==elem){
ris=1;
} else {
ris=member(bt->left, elem) || member(bt->right,elem);
}
}
return ris;
}

int contaOcc(AlberoBinario bt, int elem){
int contatore=0;
if (bt!=NULL){
contatore=contaOcc(bt->right, elem);
contatore+=contaOcc(bt->left, elem);
if(bt->label==elem){
contatore++;
}
}
return contatore;
}

int Sum(AlberoBinario bt){
int somma=0;
if (bt!=NULL && (bt->left!=NULL || bt->right!=NULL)){
somma=Sum(bt->right);
somma+=Sum(bt->left);
somma+=(bt->label);
}
return somma;
}

void inserisciOrdinato(AlberoBinario *alb, int value, int depth){
if (*alb==NULL){
AlberoBinario aux=malloc(sizeof(NodoAlbero));
aux->left=NULL;
aux->right=NULL;
aux->label=value;
*alb=aux;
} else {
if ((*alb)->label>value){
inserisciOrdinato(&((*alb)->left), value, depth+1);
} else {
inserisciOrdinato(&((*alb)->right), value, depth+1);
}
}
}

void eliminaPrimo(AlberoBinario *alb, int elem) {
int conta=0;
if (*alb!=NULL){
if ((*alb)->left==NULL && (*alb)->right==NULL && (*alb)->label==elem && conta==0) {
free(*alb);
conta=1;
} else if ((*alb)->left==NULL && (*alb)->right!=NULL && (*alb)->label==elem && conta==0) {
AlberoBinario aux;
aux=*alb;
*alb=(*alb)->right;
free(aux);
conta=1;
} else if ((*alb)->left!=NULL && (*alb)->right==NULL && (*alb)->label==elem && conta==0) {
AlberoBinario aux;
aux=*alb;
*alb=(*alb)->left;
free(aux);
conta=1;
} else {
if (conta==0) {
eliminaPrimo(&((*alb)->left), elem);
}
if (conta==0) {
eliminaPrimo(&((*alb)->right), elem);
}
}
}
}