Exercice langage C corrigé fonction arbre

Il y plusieurs choses à faire pour rendre l’arbre moins régulier. Premièrement, on peut varier l’angle entre les branches. Pour un meilleur résultat, on choisira un angle différent pour chacune des deux nouvelles branches.

Ensuite, on peut faire varier la longueur des nouvelles branches. Ici aussi, il vaut mieux utiliser des coefficients différents pour chacune des nouvelles branches.

Pour obtenir un résultat similaire à la figure d’exemple, il convient de bien choisir l’angle maximum entre les branches, ainsi que les coefficients minimum et maximum de longueur. Il est aussi conseillé d’augmenter le nombre de niveaux de l’arbre.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
#include
#include "swindow.h"
 
void dessine_arbre(SimpleWindow * window,
                   int x1, int y1, int x2, int y2, int nb_niveaux)
{
  // Dessine en vert si on se trouve au dernier niveau, en noir sinon.
  if (nb_niveaux == 0)
    window->color(0, 1, 0);
  else
    window->color(0, 0, 0);
 
  window->drawLine(x1, y1, x2, y2);
 
  if (nb_niveaux > 0) {
    const int angle_max = 50;
    const float ratio_min = 0.5;
    const float ratio_max = 0.8;
    float ratio;
 
    // Choisit aleatoirement la longueur des prochains segments
    // premiere branche
    ratio = (float(rand()) / RAND_MAX * (ratio_max-ratio_min)) + ratio_min;
    int vx1 = int(ratio * (x2 - x1));
    int vy1 = int(ratio * (y2 - y1));
    // deuxieme branche
    ratio = (float(rand()) / RAND_MAX * (ratio_max-ratio_min)) + ratio_min;
    int vx2 = int(ratio * (x2 - x1));
    int vy2 = int(ratio * (y2 - y1));
 
    // Choisit l'angle aleatoirement entre 0 et angle_max (et le convertit en radians)
    float angle = (rand() % angle_max) * 3.14159 / 180;
    int xA = int(x2 + cos(angle) * vx1 - sin(angle) * vy1);
    int yA = int(y2 + sin(angle) * vx1 + cos(angle) * vy1);
 
    // Angle different pour la deuxieme branche
    angle = (rand() % angle_max) * 3.14159 / 180;
    int xB = int(x2 + cos(-angle) * vx2 - sin(-angle) * vy2);
    int yB = int(y2 + sin(-angle) * vx2 + cos(-angle) * vy2);
 
    dessine_arbre(window, x2, y2, xA, yA, nb_niveaux - 1);
    dessine_arbre(window, x2, y2, xB, yB, nb_niveaux - 1);
  }
}
 
int main(int argc, char ** argv)
{
  const int longueur = 500;
  const int hauteur  = 500;
 
  // Initialise le generateur de nombres aleatoires
  srand(time(0));
 
  SimpleWindow window("arbre", longueur, hauteur);
  window.map();
 
  // Remplit la fenetre en blanc:
  window.color(1, 1, 1);
  window.fill();
 
  // Dessine en noir:
  window.color(0, 0, 0);
 
  // Instructions de dessin:
  dessine_arbre(&window, 250, 450, 250, 350, 10);
 
  window.show();
 
  getchar();
 
  return 0;
}

Exercice langage C corrigé fonction arbre

Voici un exercice en langage C concernant les fonctions pour manipuler des arbres binaires. L’exemple que je vais vous donner montre comment créer un arbre binaire, ajouter des éléments, et implémenter une fonction pour afficher l’arbre.

Exercice : Manipulation d’un arbre binaire

Objectif

  • Créer un arbre binaire avec des fonctions pour ajouter des nœuds.
  • Implémenter une fonction pour afficher l’arbre en parcours pré-ordre.

Code :

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

// Définition de la structure d’un nœud d’arbre binaire
struct Node {
int valeur;
struct Node* gauche;
struct Node* droite;
};

// Fonction pour créer un nouveau nœud
struct Node* creerNouveauNoeud(int valeur) {
struct Node* n = (struct Node*)malloc(sizeof(struct Node)); // Allocation mémoire
n->valeur = valeur;
n->gauche = NULL;
n->droite = NULL;
return n;
}

// Fonction pour insérer un nœud dans l’arbre binaire
struct Node* inserer(struct Node* racine, int valeur) {
// Si l’arbre est vide, créer un nouveau nœud
if (racine == NULL) {
return creerNouveauNoeud(valeur);
}

// Sinon, insérer dans l’arbre
if (valeur < racine->valeur) {
racine->gauche = inserer(racine->gauche, valeur); // Insérer à gauche
} else if (valeur > racine->valeur) {
racine->droite = inserer(racine->droite, valeur); // Insérer à droite
}

// Retourner la racine (inchangée)
return racine;
}

// Fonction pour afficher l’arbre en parcours pré-ordre (racine, gauche, droite)
void afficherPreOrdre(struct Node* racine) {
if (racine != NULL) {
printf(« %d « , racine->valeur); // Afficher la valeur du nœud
afficherPreOrdre(racine->gauche); // Afficher le sous-arbre gauche
afficherPreOrdre(racine->droite); // Afficher le sous-arbre droit
}
}

int main() {
struct Node* racine = NULL;

// Insertion de valeurs dans l’arbre
racine = inserer(racine, 50);
inserer(racine, 30);
inserer(racine, 20);
inserer(racine, 40);
inserer(racine, 70);
inserer(racine, 60);
inserer(racine, 80);

// Affichage de l’arbre en parcours pré-ordre
printf(« Affichage de l’arbre en parcours pré-ordre : « );
afficherPreOrdre(racine);
printf(« \n »);

return 0;
}

Télécharger aussi :

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

1

Besoin d'aide ?