estructura de datos de entrenamiento (III) x --- determina si hay un nodo en el árbol binario

La lista se almacena en una estructura binaria, si se prepara el valor de nodo de x se determina algoritmo de árbol binario.

[Entrada] forma dos líneas, la primera línea es la secuencia extendida preorder traversal de un árbol binario, la segunda línea es que se debe consultar nodo x
[forma] Si el nodo de salida x, salidas "SÍ", en caso contrario, la salida "NO".
entrada de la muestra [#] D ## C ## AB
D
[] ejemplo de salida
SÍ

BiTree.h archivo (incluido en el preámbulo de recorrido) :

BITREE_H_INCLUDED #ifndef
 #define BITREE_H_INCLUDED
 el uso de  espacio de nombres de enfermedades de transmisión sexual;
 // Definido Nodo 
plantilla <nombre de tipo DataType> struct BiNode 
{ 
    los datos Tipo de datos; 
    BiNode <DataType> lchild *, * rchild; 
}; 
plantilla <nombre de tipo del Tipo de datos>
 clase BiTree 
{ público :
     // función de la construcción, un uno binario     BiTree () 
    { 
        la raíz = Creat (); 
    } // comunicados destructor el espacio de almacenamiento del nodo 
    ~ BiTree () 
    { 
    } //





     
        liberación (la raíz);

    Preorden recorrido de un árbol binario 
    vacío preorden () 
    { 
        preorden (la raíz); 
    } 

    // preorden árbol binario de 
    anular el finde () 
    { 
        el finde (la raíz); 
    } 

    // orden posterior árbol binario 
    vacío orden posterior () 
    { 
        orden posterior (la raíz); 
    } 

    / / presencia o ausencia de X determina el número 
    BOOL ExistX (el Tipo de datos X) 
    { 
        volver ExistX (la raíz, X); 
    } 
privado : 
    BiNode <DataType> * Creat ();
     vacío de lanzamiento (BiNode <DataType> * BT);
     nulaPreorden (BiNode <DataType> * BT);
     sin efecto el finde (BiNode <DataType> * BT);
     sin efecto orden posterior (BiNode <DataType> * BT);
     BOOL ExistX (BiNode <DataType> * BT, el Tipo de datos X); 
    BiNode <DataType> * la raíz; 

}; 

// función de construcción, uno binario 
plantilla <nombre de tipo DataType> 
BiNode <DataType> * BiTree <DataType> :: Creat () 
{ 
    BiNode <DataType> * BT;
     Char CH; 
    CIN >> CH;                     / / entrada de información de datos de nodo 
    IF (CH == '# ') 
        BT = nullptr una;     // construir un árbol vacío 
    la otra 
    { 
        BT = nueva nueva BiNode <DataType> ; 
        BT -> Datos = CH; 
        BT -> lchild = Creat ();    // recursiva subárbol izquierdo establecer 
        BT-> rchild = creat ();    // recursivas subárbol derecho establecido 
    }
     volver BT; 
} 

// comunicados destructor del espacio de almacenamiento del nodo 
plantilla <nombre de tipo DataType> vacío BiTree <DataType> :: liberación (BiNode <DataType> * BT) 
{ SI (BT == nullptr a)
         de retorno ;
    

    otra cosa 
    { 
        Release (bt -> lchild); 
        Release (bt -> rchild);
        eliminar bt; 
    } 
} 

// 前序遍历二叉树 
plantilla <nombre de tipo Tipo de datos> vacío BiTree <Tipo de datos> :: preorden (BiNode <Tipo de datos> * bt) 
{ si (t == nullptr)
         de retorno ;
    otra cosa 
    { 
        cout << BT-> datos; 
        Preorden (bt -> lchild); 
        Preorden (bt -> rchild); 
    } 
} // 中序遍历二叉树

    


plantilla <nombre de tipo Tipo de datos> vacío BiTree <Tipo de datos> :: finde (BiNode <Tipo de datos> * bt) 
{ si (t == nullptr)
         de retorno ;
    otra cosa 
    { 
        finde (bt -> lchild); 
        cout <<> BT- datos; 
        Finde (bt -> rchild); 
    } 
} // 后序遍历二叉树 
plantilla <nombre de tipo Tipo de datos> vacío BiTree <Tipo de datos> :: orden posterior (BiNode <Tipo de datos> * bt) 
{ si (t == nullptr)
         de retorno ;
    más

    



     
    {
        Orden posterior (ta -> lchild); 
        Orden posterior (ta -> rchild); 
        cout <<> BT- datos; 
    } 
} 

// 判断是否存在X 
plantilla <nombre de tipo Tipo de datos> bool BiTree <Tipo de datos> :: ExistX (BiNode <Tipo de datos> * bt, Tipo de datos x) 
{ si (t == nullptr)
         de retorno falsa ;
    otra cosa si (BT> Datos == x) 
    { retorno verdadera ; 
    } Demás 
    { si (ExistX (BT> lchild, x))
             de retorno

      
         
    
         verdadera ;
        si (ExistX (BT> rchild, x))
             de retorno  verdadera ; 
    } 
    Devolver  falsa ; 
} 

#Endif  // BITREE_H_INCLUDED

 

main.cpp archivo :

#include <iostream> 
#include " BiTree.h " 
el uso de  espacio de nombres std; 

int main () 
{ 
    BiTree < Char > t;
    Char CH; 
    cin >> CH;
    si (t.ExistX (CH)) { 
        cout << " SÍ " ; 
    } 
    Demás { 
        cout << " NO " ; 
    } 
}