Algoritmo para encontrar el número de nodos de hoja en un árbol binario (c)

La implementación del código del árbol binario es la siguiente:

// Nombre de archivo: btree.h#ifndef __BINARY_TREE_H__

#define __BINARY_TREE_H__#include lt;

#include lt; crtdbg.hgt; #ifdef _DEBUG

#define DEBUG_NEW nuevo (_NORMAL_BLOCK, ESTE_FILE, __LINE__)

#endif#ifdef _DEBUG

#definir nuevo DEBUG_NEW

#undef THIS_FILE

carácter estático THIS_FILE[] = __FILE__;

#endif#ifdef _DEBUG

# ifndef ASERT

#define ASERT afirmar

#endif

#else // no _DEBUG

#ifndef ASERT

#define ASSERT

#endif

#endif

#endif // _DEBUGtemplate lt; tipo nombre Tgt

clase CBTNode<; /p>

{

público:

T datos;

CBTNodelt;*padre; ; *izquierda;

CBTNodelt; *derecha

CBTNode(

T datos = T(),

CBTNodelt; Tgt; *padre = NULL,

CBTNodelt; *izquierda = NULL,

CBTNodelt; ), padre(padre), izquierda(izquierda), derecha(derecha) {}

}; typename T gt

clase CBTree

{

protegido:

CBTNodelt; Tgt; *m_pNodeRoot; público:

CBTree(CBTNodelt; Tgt; *initroot = NULL); > ~CBTree() ;

void AssignTo(CBTNodelt; Tgt; *p);

void Copiar(CBTreelt; Tgt; amp; p); p> CBTNodelt; Tgt; amp; p); privado:

CBTNodelt; *p; void PreOrderTraverse(

const CBTNodelt;Tgt;*p,

vacío

(* Visita)(const T & data)

) const; void InOrderTraverse(

const CBTNodelt; Tgt; *p,

void (*Visita) (const T amp; datos)

) const; void PostOrderTraverse(

const CBTNodelt; Tgt; *p,

void (*Visita)(const T amp; datos)

) const; void GetNodesCount( const CBTNodelt; Tgt; *p, unsigned int *unCount) const; público:

Tamp; GetNodeData(CBTNodelt; Tgt; *p);

T GetNodeData(const CBTNodelt; Tgt; *p)

void SetNodeData; (CBTNodelt; Tgt; *p, const T amp; datos);

CBTNodelt; *amp; GetRoot();

CBTNodelt;

CBTNodelt;Tgt; *amp; GetParent(CBTNodelt;Tgt; *p);

CBTNodelt;Tgt;* GetParent(const CBTNodelt;Tgt; *p) const;

CBTNodelt; Tgt; *amp; GetLeftChild(const CBTNodelt; *p);

CBTNodelt; * GetLeftChild(const CBTNodelt; *p) const; CBTNodelt; *amp; CBTNodelt; Tgt; *p);

CBTNodelt; p> CBTNodelt; >

CBTNodelt; Tgt; * GetLeftSiblig(const CBTNodelt; *p) const;

CBTNodelt; *amp GetRightSibling(CBTNodelt; *p);

CBTNodelt; Tgt; * GetRightSibling(const CBTNodelt; Tgt; *p) const;

int IsEmpty()

void Destroy(); >

anular PreOrderTraverse

(void (*Visita)(const T amp; datos)) const;

void InOrderTraverse( void (*Visita)(const T amp; datos))

void PostOrderTraverse; (void (*Visit)(const T amp; data)) const;

unsigned int GetNodesCount() const // Obtener cuántos nodos

unsigned int GetLeafCount() const;

unsigned int GetDepth() const;

unsigned int GetDepth(const CBTNodelt; Tgt; *p) const

}; /p>

CBTreelt en línea;:: CBTree(CBTNodelt; Tgt; * initroot): m_pNodeRoot(initroot)

{

}templatelt; p>

p>

CBTreelt en línea;Tgt;::~CBTree()

{

Destroy();

}templatelt; typename Tgt;

p>

inline void CBTreelt;Tgt;::AssignTo(CBTNodelt;Tgt; *p)

{

ASSERT(p

m_pNodeRoot = p;

}templatelt;typename Tgt;

inline void CBTreelt;Tgt;::Copy(CBTreelt;Tgt; amp;p); )

{

if (NULL != p.m_pNodeRoot)

m_pNodeRoot = Copiar(p.m_pNodeRoot)

}templatelt; typename Tgt;

inline CBTNodelt;Tgt; return p-gt;parent;

}templatelt;typename Tgt;

inline Tamp; :GetNodeData(CBTNodelt;Tgt; *p)

{

ASSERT(p);

devuelve datos p-gt; >}templatelt; nombre de tipo Tgt;

inline T CBTreelt;: .GetNodeData(const CBTNodelt; Tgt; *p) const

{

ASSERT( p);

devolver p-gt;

ta;

}templatelt;typename Tgt;

inline void CBTreelt;Tgt;:SetNodeData(CBTNodelt;Tgt; *p, const T amp;data)

{

ASSERT(p);

p-gt; datos = datos

}templatelt; tipo de nombre Tgt; int CBTreelt; ::IsEmpty() const

{

return NULL == m_pNodeRoot;

}typename Tgt;

CBTNodelt en línea;Tgt;*amp; CBTreelt;Tgt;::GetRoot()

{

return *(amp;(m_pNodeRoot));

} templatelt;typename Tgt;

CBTNodelt en línea;Tgt;* CBTreelt;Tgt;:

getRoot() const

{

return m_pNodeRoot;

} templatelt; typename Tgt;

inline void CBTreelt;:: DestroyNode(CBTNodelt; Tgt; *p)

{

if (p)

{

DestroyNode(p-gt; izquierda

DestroyNode(p-gt; derecha) ;

eliminar p;

}

}templatelt;typename Tgt;

inline void CBTreelt;Tgt;::Destroy()

{

DestroyNode(m_pNodeRoot);

m_pNodeRoot = NULL

}nombre de tipo Tgt; CBTreelt vacío en línea;: PreOrderTraverse(void (*Visit)(const T amp; data)) const

{

PreOrderTraverse(m_pNodeRoot, Visit); p>}templatelt;typename Tgt;

inline void CBTreelt;Tgt;::PreOrderTraverse(

const CBTNodelt;Tgt; *p,

void (* Visita)(const T amp; data)

) const

{

if (p)

{

Visita(p-gt; datos);

PreOrderTraverse(p-gt; izquierda, Visita

PreOrderTraverse(p-gt; plataforma);

ht, Visita);

}

}templatelt; typename Tgt;

inline void CBTreelt;: .InOrderTraverse(void (*Visita)(const) T amp; datos)) const

{

InOrderTraverse(m_pNodeRoot, Visit

}templatelt; void CBTreelt;Tgt;::InOrderTraverse(

const CBTNodelt;Tgt; *p,

void (*Visit)(const T&data)

) const

{

if (p)

{

InOrderTraverse(p-gt; izquierda, Visita);

Visita(p-gt; datos);

InOrderTraverse(p-gt.right, Visita

}

}nombre de tipo Tgt;

CBTreelt vacío en línea;Tgt;: PostOrderTraverse(void (*Visit)(const T amp.data) const

{

PostOrderTraverse(m_pNodeRoot, Visit);

}templatelt;typename Tgt;

inline void CBTreelt;Tgt;:.PostOrderTraverse(

const CBTNodelt;Tgt; *p,

void (*Visita)(const T amp; datos)

) const

{

if (p)

{

PostOrderTraverse(p-gt; izquierda, Visita);

PostOrderTraverse(p-gt; derecha, Visita

Visita(p -gt;data); );

}

} templatelt;typename Tgt;

inline unsigned int CBTreelt;Tgt;::GetNodesCount() const

{

unsigned int unCount

GetNodesCount(m_pNodeRoot, amp; unCount

return unCount

} templatelt;typename Tgt; ;

inline void CBTreelt;Tgt;:.GetNodesCount(

const CBTNodelt;Tgt; *p,

unsigned int *unCount

) const

{

ASSERT(unCou

nt); unsigned int unLeftCount;

unsigned int unRightCount; si (NULL == p)

*unCount = 0

si ((NULL =; = p-gt; izquierda) amp; (NULL == p-gt.right))

*unCount = 1;

GetNodesCount(p-gt; izquierda, y unLeftCount);

GetNodesCount(p-gt; derecha, y unRightCount);

GetNodesCount(p); -gt;right, amp;unRightCount);

*unCount = 1 unLeftCount unRightCount;

}

}templatelt;typename Tgt;

inline unsigned int CBTreelt;Tgt;::GetLeafCount() const

{

unsigned int unCount = 0;

GetLeafCount(m_pNodeRoot, amp;unCount );

return unCount;

}templatelt; typename Tgt;

inline void CBTreelt;: GetLeafCount(

const CBTNodelt; tgt; *p,

unsigned int *unCount

) const

{

ASSERT(unCount);

{

// Si los nodos secundarios izquierdo y derecho de un nodo son NULL, entonces debe ser un nodo hoja

if ((NULL == p-gt ;izquierda) amp; (NULL == p-gt;derecha))

(*unCount);

GetLeafCount(p-gt;izquierda, unCount);

p>

GetLeafCount(p-gt; derecha, unCount);

}

}templatelt; tipo de nombre Tgt; unsigned int CBTreelt; Tgt .::GetDepth() constante

{

// Resto 1 aquí porque creo que la profundidad del nodo raíz debería ser 0.

// Entonces, si crees que la profundidad del nodo raíz debería ser 1, no lo hagas.

return GetDepth(m_pNodeRoot) - 1;

}templatelt; typename Tgt;

inline unsigned int CBTreelt;: .GetDepth(const CBTNodelt; Tgt ; *p) const

{

unsigned int unDepthLeft;

unsigned int unDepthRight; >

unDepthLeft = GetDepth(p-gt; left);

unDepthRight = GetDepth(p-gt; right);

return 1 // Si no se agrega 1 aquí , La profundidad del árbol siempre será 0

(unDepthLeft gt; unDepthRight ? unDepthLeft : unDepthRight

}

else