Aplicación transversal del árbol binario Uno

El recorrido del árbol binario se refiere al acceso a cada nodo en el árbol en un cierto orden. Debido a la naturaleza recursiva de un árbol binario, se puede considerar que un árbol binario no vacío consta de tres partes: el nodo raíz, el subárbol izquierdo y el subárbol derecho. Al atravesar la información de estas tres partes, el árbol binario se atraviesa.

Almacenamiento secuencial de árbol binario completo para almacenamiento en cadena

Un árbol binario completo se almacena en una matriz unidimensional T [n], y los valores de cada nodo se leen secuencialmente desde T [0] para establecer una representación de lista vinculada del árbol binario

Como la matriz unidimensional se almacena a partir del número 0, el elemento secundario izquierdo del nodo i es 2i + 1, y el elemento secundario derecho es 2i + 2.

void A_to_L(Type T[],int n,int i,BiTNode *&p)
{//利用引用型参数p将形参的值带回实参 
	if(i>=n)
	{
		p=NULL;
	} 
	else
	{
		p=(BiTNode*)malloc(sizeof(BiTNode));//建立根结点 
		p->data=T[i];
		A_to_L(T,n,2*i+1,p->lchild);        //递归建立左子女 
		A_to_L(T,n,2*i+2,p->rchild);        //递归建立右子女
	}
}

Almacenamiento completo de cadena de árbol binario a almacenamiento secuencial

El algoritmo recursivo también se utiliza, suponiendo que la raíz t debe almacenarse en T [i], luego su hijo izquierdo se almacena en T [2i + 1], y su hijo derecho se almacena en T [2i + 2]

void L_to_A(BiTNode *t,Type T[],int n,int i)
{
	if(t==NULL) return;
	if(i>=n)
	{
		cout<<"数组空间不足"<<endl; 
	}
	else
	{
		T[i]=t;
		L_to_A(t->lchild,T,n,2*i+1);
		L_to_A(t->rchild,T,n,2*i+2);
	}
}

Imprime los nodos de un árbol binario

Árbol binario con almacenamiento en cadena, genera cada nodo en forma de raíz (L, T)

void print_BiT(BiTNode *t)
{
	if(t!=NULL)
	{
		cout<<t->data;
		if(t->lchild!=NULL||t->rchild!=NULL)
		{
			cout<<"(";
			print_BiT(t->lchild);
			if(t->rchild!=NULL)
			{
				cout<<",";
				print_BiT(t->rchild);				
			}
			cout<<")";
		}
	}
}

Calcular el número de nodos con un grado de 1 en el árbol binario

Si el árbol binario está vacío, devuelve directamente 0; si no está vacío, los nodos con un grado de 1 en los subárboles izquierdo y derecho de la raíz se cuentan a su vez, y luego el nodo raíz se verifica para un grado de 1;

int D_is_1(BiTNode *t)
{
	if(t==NULL) 
	{
	   return 0;
	}
	else
	{
		if((t->lchild!=NULL&&t->rchild==NULL)||(t->lchild==NULL&&t->rchild!=NULL))
		{
			return (1+D_is_1(t->lchild)+D_is_1(t->rchild));
		}
		else
		{
			return(D_is_1(t->lchild)+D_is_1(t->rchild));
		} 
	}
}

Calcular el número de nodos con un grado de 2 en el árbol binario

int D_is_2(BiTNode *t)
{
	if(t==NULL) 
	{
	   return 0;
	}
	else
	{
		if(t->lchild!=NULL&&t->rchild!=NULL)
		{
			return (1+D_is_2(t->lchild)+D_is_2(t->rchild));
		}
		else
		{
			return(D_is_2(t->lchild)+D_is_2(t->rchild));
		} 
	}
}

Calcular el número de nodos con un grado de 0 en el árbol binario

int D_is_0(BiTNode *t)
{
	if(t==NULL) 
	{
	   return 0;
	}
	else
	{
		if(t->lchild==NULL&&t->rchild==NULL)
		{
			return 1;
		}
		else
		{
			return(D_is_0(t->lchild)+D_is_0(t->rchild));
		} 
	}
}

Cuenta la altura del árbol binario

Si el árbol binario está vacío, la altura es 0; si el nodo raíz es un nodo hoja, la altura es 1; de lo contrario, se cuenta la altura de los subárboles izquierdo y derecho

int height(BiTNode *t)
{
	if(t==NULL) 
	{
	   return 0;
	}
	else
	{
		int lheight,rheight;
		lheight=height(t->lchild);
		rheight=height(t->rchild);
		return (1+(lheight>rheight)?lheight:rheight);		
	}
}

Cuenta la profundidad de un nodo en un árbol binario

Si el nodo p es el nodo raíz, se devuelve el nivel de t (d, el valor inicial es 1); de lo contrario, el subárbol izquierdo se busca de forma recursiva, y si no se encuentra, el subárbol derecho es recursivo y no se encuentra ninguno y devuelve 0;

int level(BiTNode *t,BiTNode *p,int d)
{
	if(t==NULL) 
	{
	   return 0;
	}
	else if(t==p)
	{
		return d;
	}
	else
	{
		int subTreelevel;
		if((subTreelevel=level(t->lchild,p,d+1))>0)
		{
			return subTreelevel;
		}
		else if((subTreelevel=level(t->rchild,p,d+1))>0)
		{
			return subTreelevel;
		}
		else
		{
			return 0;
		}	
	}
}