Créer une liste vide et tester si une liste est vide.

Pile Liste doublement chaînée avec un seul pointeur

struct maillon{ struct maillon{ struct maillon{
int donnee; void* donnee; struct maillon* precedent;
struct maillon* suivant; }; struct maillon* suivant; }; int donnee;
typedef struct maillon liste; typedef struct maillon pile; struct maillon* suivant; };
liste *tete=NULL; typedef struct maillon liste_d;
ajouter en sommet un élément. liste_d *tete;
liste *creation_Liste(){ pile *haut=NULL;
liste *nouveau, * courant; ajouter en sommet un élément. Liste doublement chaînée avec deux pointeurs
Liste *tete; pile *empiler(pile *haut, int valeur){ struct maillon{
int valeur; pile *nouveau; struct maillon* precedent;
tete=NULL nouveau=(pile*)malloc(sizeof(pile)); int donnee;
nouveau=(liste*)malloc(sizeof(liste)); nouveau->donnee=valeur; struct maillon* suivant; };
scanf(“%d”, &valeur); if(haut==NULL){ typedef struct maillon liste_d;
nouveau->suivant= NULL; nouveau->suivant=NULL; liste_d *tete;
nouveau->donnee=valeur; haut=nouveau;} liste_d *queue;
else{
tete=nouveau;} nouveau->suivant=haut; Création d’une liste doublement chaînée
return tete;}} haut=nouveau;} liste_d *creer_liste_double(liste_d *tete){
return haut;} liste_d *nouveau, *courant;
Afficher une liste. supprimer du sommet le dernier élément de la pile. int valeur;
liste *afficher_liste(liste *tete){ pile *depiler(pile *haut){ printf("Entrer la donnee : \n ");
liste *courant; pile *courant; scanf("%d", &valeur);
courant = tete; courant=haut; if(tete==NULL){
while(courant!=NULL){ if(haut==NULL) printf("la pile est vide \n"); nouveau=(liste_d*)malloc(sizeof(liste_d));
printf(“\t %d”, courant->donnee); else{ nouveau->precedent=NULL;
courant=courant->suivant;} haut=haut->suivant; nouveau->donnee=valeur;
return tete;} printf("\n la valeur supprimée est : %d ", courant->donnee); nouveau->suivant=NULL;
free(courant);} tete=nouveau;}
Ajouter un maillon à la liste (en tête, en queue ou au milieu). return haut;} return tete;
liste *inserer_tete(liste *tete){ else{
liste *nouveau; int renvoie_premier_element(pile *haut){ courant=tete;
int valeur; if(haut==NULL) return -1; nouveau=(liste_d*)malloc(sizeof(liste_d));
printf(“Entrer la donnée \n “); else return haut->donnee; } nouveau–>donnee=valeur;
scanf(“%d”, &valeur); while(courant–>suivant!=NULL){
nouveau=(liste*)malloc(sizeof(liste)); Afficher les éléments de la la pile courant=courant–>suivant;}
nouveau->donnee=valeur; pile *afficher_pile(pile *haut){ courant–>suivant=nouveau;
nouveau->suivant=tete; pile *courant; nouveau–>precedent=courant;
tête=nouveau; if(haut==NULL) printf("la pile des vide \n "); nouveau–>suivant=NULL; } }
return tete; } else{ return tete; }
courant=haut;
liste *inserer_queue(liste *tete){ while(courant!=NULL){ Affichage d’une liste doublement chaînées
liste *courant, *nouveau; printf("%d \n", courant->donnee); afficher_liste_double(liste_d *tete){
int valeur; courant=courant->suivant;} } liste_d *courant;
printf(“Entrer la donnée : \n “); return haut;} courant=tete;
scanf(“%d”, &valeur); while(courant!=NULL){
nouveau=(liste *)malloc(sizeof(liste)); tester si la pile est vide. printf("\t %d", courant->donnee);
nouveau->donnee=valeur; tester si la pile est plein. courant=courant->suivant; } }
courant=tete; Représentation dynamique d’un arbre binaire
while(courant->suivant!=NULL) File struct nœud{
{courant=courant->suivant; } Structure d’un élément de la file int donnee;
courant->suivant=nouveau; struct element{ struct nœud* gauche;
nouveau->suivant=NULL; int donnee; struct nœud* droit; };
return tete;} struct element *suivant;}; typedef struct nœud arbre;
typedef struct element maillon; La création d’un arbre vide
Supprimer un maillon (en tête, en queue ou au milieu). void creer_arbre(arbre *racine){
liste *supprimer_tete(liste *tete){ Structure de la file racine=NULL; }
liste *courant; struct queue{
courant=tete; struct element *premier; Suppression d’un arbre binaire
tete=tete->suivant; struct element *dernier; }; arbre *supprimer_arbre(arbre *racine){
free(courant); typedef struct queue file; if(racine!=NULL){
return tete;} supprimer_arbre(racine–>gauche);
Création d’une file vide supprimer_arbre(racine–>droit);
liste *supprimer_queue(liste *tete){ void creer_file(file *q){ free(racine);}
liste *courant, *precourant; q->premier=NULL; return racine; }
courant=tete; q->dernier=NULL; } Taille d’un abre binaire
while(courant->suivant!=NULL){ int taille(arbre *racine){
precourant=courant; ajouter en queue. if(racine==NULL) return 0;
courant=courant->suivant;} file *enfiler_element(file *q, int valeur){ else
precourant->suirant=NULL; maillon *nouveau; return(taille(racine–>gauche)+taille(racine–>droit)+1);}
free(courant); nouveau=(maillon*)malloc(sizeof(maillon));
return tete;} nouveau->donnee=valeur; Nombre total des nœuds (feuilles)
if(q->premier==NULL){ int ex_nœud(arbre *racine){
liste *supprimer_element(liste *tete){ q->premier=nouveau; if(racine==NULL) return 0;
liste *courant, *precourant; q->dernier=nouveau; else if((racine–>gauche==NULL)&&(racine–>droit==NULL))
int val; q->premier->suivant=NULL; return 1;
printf(“Entrez la valeur de l’élément à supprimer :\n “); q->dernier->suivant=NULL;} else
scanf(“%d”, &val); return (ex_nœud(racine–>gauche)+ex_nœud(racine–>droit));}
courant=tete; else{
if(courant->donnee==val){ q->dernier->suivant=nouveau; Parcours infixé
tete=supprimer_tete(tete); q->dernier=nouveau; void parcours_Infixe(arbre *racine){
return tete;} q->dernier->suivant=NULL;} if(racine!=NULL){
else{ while(courant->donnee!=val){ return q;} parcours_Infixe(racine->gauche);
precourant=courant; supprimer en tête. printf("%d \t", racine->donnee);
courant=courant->suivant;} file *defiler_element(file *q){ parcours_Infixe(racine->droit);} }
precourant->suivant=courant->suivant; maillon *courant;
free(courant); courant=q->premier; Opérations de Recherche
return tete;}} if(q->premier==NULL) printf("la file est vide \n"); arbre *rechercher_element(arbre *racine, int valeur){
else{ if(((valeur==racine->donnee))
Trié une liste. q->premier=q->premier->suivant; return racine;
liste *trier_list(liste *tete){ free(courant);} else if (valeur < racine->donnee)
liste *courant1, *courant2; return q;} return rechercher_element(racine->gauche, valeur);
int temp; else
courant1=tete; int renvoie_premier_element(file *q){ return rechercher_element(racine->droit, valeur); }
while(courant1->suivant!=NULL){ if(q->premier==NULL){
courant2=courant1->suivant; printf("la file est vide \n"); Recherche de plus grand nœud
while(courant2!=NULL) { return –1;} arbre * trouver_plus_grand_nœud(arbre *racine){
if(courant1->donnee > courant2->donnee){ else return q->premier->donnee; } if((racine==NULL)||(racine->droit==NULL))
temp=courant1->donnee; return racine;
courant1->donnee=courant2->donnee; tester si la file est vide. else
courant2->donnee=temp; } tester si la file est plein. return trouver_plus_grand_nœud(racine->droit); }
courant2=courant2->suivant;}
courant1=courant1->suivant; } Recherche de plus petit nœud
return tete; } arbre * trouver_plus_petit_nœud(arbre *racine){
if((racine==NULL)||(racine->gauche==NULL))
liste *supprimer_liste(liste *tete){ return racine;
liste *courant; else
if(tete!=NULL){ return trouver_plus_petit_nœud(racine->gauche); }
courant=tete;
while(courant!=NULL){
printf(“%d est à supprimer suivant \n”, courant->donnee);
tete=supprimer_tete(courant);
courant=tete; } }
return tete};