Formación de estructura de datos (III) --- anchura árbol binario

Descripción] [Problemas
a estructura de lista binario para el almacenamiento, la preparación de una anchura algoritmo de árbol binario (el número de nodos que tienen el mayor número de nodos que capa).

[Entrada] forma dos líneas, la primera línea se extiende secuencia preorder traversal de un árbol binario.
[Forma] la anchura de la salida de un árbol binario.
de entrada de muestra] [AB # D ## C ##
[] Ejemplo de salida

main.cpp archivo :

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

int main () 
{ 
    BiTree < Char > t; 
    cout << t.TreeWidth (); 
}

 

BiTree.h archivo (con unas pocas preguntas sobre el método binario) :

BITREE_H_INCLUDED #ifndef
 #define BITREE_H_INCLUDED 
# include <cola>
 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 construcción, uno binario     BiTree () 
    { 
        la raíz = Creat (); 
    } // comunicados destructor del espacio de almacenamiento del nodo 
    ~





     BiTree ()
    {
        Al liberar (raíz); 
    } 

     XLay ( raíz, x);// 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 () 
    { 
        postorden (la raíz); 
    } 

    // número determina si hay o no X- 
    BOOL ExistX (el DataType x) 
    { 
        volver ExistX (la raíz, x); 
    } 

    // capas nodo x se encuentra 
    int XLay (el DataType x) 
    { 
        retorno
    } 

    //求二叉数的宽度
    int TreeWidth ();
privada : 
    BiNode <Tipo de datos> * Creat ();
    vacío de lanzamiento (BiNode <Tipo de datos> * bt);
    vacío preorden (BiNode <Tipo de datos> * bt);
    vacío finde (BiNode <Tipo de datos> * bt);
    sin efecto orden posterior (BiNode <Tipo de datos> * bt);
    bool ExistX (BiNode <DataType> * bt, DataType x);
    int XLay (BiNode <DataType> * bt, DataType x); 
    BiNode <Tipo de datos> * raíz; 

}; 

// 构建函数,建立一颗二叉树 
plantilla <nombre de tipo Tipo de datos><La DataType> * BiTree <la DataType> :: Creat () 
{ 
    BiNode <la DataType> * BT;
     Char CH; 
    CIN >> CH;                     // información de datos de nodo de entrada 
    IF (CH == ' # ' ) 
        BT = nullptr a;     // establecer 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 ();    recursiva establecer el subárbol derecho     }
     regreso //
BT; 
} 

// comunicados destructor del espacio de almacenamiento del nodo 
plantilla <nombre de tipo DataType> vacío BiTree <DataType> :: Release (BiNode <DataType> * BT) 
{ SI (BT == nullptr a)
         de retorno ;
     la otra 
    { 
        Release (BT -> lchild); 
        Release (BT -> rchild);
         Eliminar BT; 
    } 
} // preorden recorrido de un árbol binario 
plantilla <nombre de tipo DataType> vacío BiTree <DataType> :: preorden (BiNode <DataType> * BT) 
{ SI

    



    (bt == 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 ;
    otra cosa 
    { 
        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

    



    (bt == nullptr)
         retorno  falsa ;
    otra cosa  si (BT> Datos == x) 
    { 
        retorno  verdadera ; 
    } 
    Demás 
    { 
        si (ExistX (BT> lchild, x))
             volver  verdadera ;
        si (ExistX (BT> rchild, x))
             de retorno  verdadera ; 
    } 
    Devolver  falsa ; 
} 

// 存在节点X的层数 
plantilla <nombre de tipo Tipo de datos> int BiTree <Tipo de datos> :: XLay (BiNode <Tipo de datos> * bt, Tipo de datos x) 
{

    int cuna = 0 ;
    Si(bt == nullptr)
         de retorno cuna;
    más  si (BT> datos == x) 
    { 
        cuna = 1 ;
        volver cuna; 
    } 
    Más 
    { 
        si (XLay (BT> lchild, x)) 
        { 
            cuna = XLay (BT> lchild, x) + 1 ;
            volver cuna; 
        } 
        Si (XLay (BT> rchild, x)) { 
            cuna = XLay (BT> rchild, x) + 1 ;
            volver cuna; 
        } 
    }
    retorno COT; 
} 

Plantilla <TypeName la DataType>
 int BiTree <la DataType> :: TreeWidth () 
{ 
    Queue <BiNode <la DataType> *> Q;   // cola de aplicación es un tipo de unión de tipo de cola: <BiNode <DataType> * > 
    int W;
     SI (la raíz == NULL)   // árbol es ancho vacío de cero 
        retorno  0 ;
     la otra cosa 
    { 
        Q.push (la raíz);    // raíz enqueue 
        W = 1. ;
         int maxw;        // establecer una variable de número entero máximo depósito 
        maxw = W;
         el tiempo (Q.empty ()!)            // determina si la cola está vacía que representa el recorrido completo 
        {
             para ( int I = 0 ; I <W; I ++)     // el nodo quitadas de la cola sus nodos hijos en cola 
            {
                 IF (Q.front () -> lchild = NULL) 
                Q.push (Q.front () -> lchild);
                 SI ! (Q.front () -> rchild = NULL) 
                Q.push (Q.front () -> rchild); 
                Q .pop ();     // el nodo quita de la cola 

            } 
            W = Q.size ();
             IF (maxw <W)   //Se asegurará de que cada maxw más grande 
                maxw = W; 
        } 
        volver maxw; 
    } 
} 
#endif  // BITREE_H_INCLUDED