#include
#include
à l’aide d’un espace de noms std;
// structure de données pour stocker un nœud d’arbre binaire
noeud de structure
{
clé int;
nœud * laissé, * droite;
};
// fonction pour créer un nouveau nœud d’arbre binaire ayant donné une clé
nœud * newnode (clé INT)
{
nœud * nœud = nouveau noeud;
nœud- > clé = clé;
nœud- > gauche = nœud- > droite = nullptr;
nœud de retour;
}
// fonction récursive pour effectuer une traversée d’une arborescence binaire
vide inoordorttraversal (noeud * racine )
{
si (root == nullptr)
retour;
inordertraversal (racine- > GAUCHE);
COUT <
inordertraversal (racine- iv ID = «
à droite);
}
// fonction récursive pour effectuer la traversée de fixation d’un arborescence binaire
void preordertraversal (noeud * racine)
{
si (racine == nullptr)
retour;
COUT < < racine- > clé
»;
pré-commandeTraversal (root- > gauche);
pré-commandeTraversal (racine-
droite );
}
// fonction récursive pour construire une arborescence binaire à partir de
// introduction et séquence pré-commande
nœud * Construire (Vector < INT > const & Indommager, int start, int. / p>
vecteur < int > const & Pré-commande, int
pindex,
Unommked_map < int, int >
map)
{
// cas de base
si (Démarrer > fin )
retour nullptr;
// L’élément suivant en pré-commande sera le nœud racine du sous-arbre
// formé par INDOMODER
Noeud * racine = newnode (pré-commande);
// obtenir l’index du nœud racine dans INDERODER pour déterminer la limite
// de la sous-arbre gauche et droite
int index = carte;
// construisez récursivement le sous-arbre gauche
racine- > de gauche = construire (INRONDER, START, Index – 1, pré-commande, pindex, carte);
// construit récursivement le sous-arbre droit
racine- > droite = construire ( Informer, index + 1, fin, pré-commande, pindex, carte);
// renvoie le nœud actuel
racine de retour;
}
// Construisez un arbre binaire à partir d’entraîneurs Indommager et pré-commande
// Cette fonction suppose s que l’entrée est valide
// c’est-à-dire que l’introductif et la séquence pré-commander forme une arborescence binaire
nœud * construction (vecteur < int > const & inondéraire, Vector < int > const & pré-commande)
{
// obtenir le nombre de nœuds dans l’arborescence
int n = inorder.size ();
// crée une carte pour trouver efficacement l’index de tout élément dans
// étant donné la séquence inerchente
non ordonnée_map < int, int > carte;
pour (int i = 0; i < n; i ++)
carte] = i;
// pindex enregistre l’index du prochain nœud non transformé dans la séquence pré-commande
// Démarrer avec le nœud racine (présent à 0 ‘th index)
int pindex = 0;
Construction de retour (INDUCTION, 0, N – 1, Pré-commande, Pindex, Carte);
}
// fonction principale
int Main ()
{
/ * considère ci-dessous de l’arborescence
2 3