Apuntes de clase: ejercicios de diseño de algoritmos de árbol binario

Recorrer el árbol binario es la base de varias operaciones del árbol binario. La operación de acceso a cada nodo en el algoritmo transversal puede ser de varias formas y operaciones múltiples. De acuerdo con el marco del algoritmo transversal, el contenido de la operación de acceso puede modificarse adecuadamente para derivar una gran cantidad de árboles binarios. Algoritmo de aplicación.
Algoritmo de diseño para encontrar el número de nodos del árbol binario

void Count(BiNode *root){     
	if (root){          
		Count(root->lchild);          
		number++;//number为数据成员
		Count(root->rchild);    
	} 
}

El número de nodos en el árbol = el número de nodos en el subárbol izquierdo + el número de nodos en el subárbol derecho + 1

template<class T>
int BiTree<T>::count(BiNode<T>* root){  
	int number=0;  
	if (root==NULL)   
		number=0;  
	else   
		number=count(root->lchild)+count(root->rchild)+1;  	
	return number; 
}

Cuente el número de nodos hoja.
Agregue un miembro de datos, número de hojas y el valor inicial es 0. Atraviese el árbol, si un nodo es una hoja, el recuento de hojas + 1; puede calcularse en el proceso transversal del preorden, el orden medio o el postorden.
El análisis del algoritmo
comienza desde el nodo raíz y determina si el nodo actual es un nodo hoja. Si es así, el número de hojas es +1. De lo contrario, atraviesa el subárbol izquierdo y cuenta el número de nodos hoja. Atraviesa el subárbol derecho y cuenta El número de nodos de hoja.

template<typename T>
void BiTree<T>:: countleaf(BiTreeNode<T> * root){  
	if (root){   
		if (root->lchild==NULL && root->rchild==NULL)    
			leafcount=leafcount+1;   
		else{    
			countleaf(root->lchild);    
			countleaf(root->rchild);   
		}  
	}  
	return; 
}

Número de nodos hoja en el árbol = número de nodos hoja en el subárbol izquierdo + número de nodos hoja en el subárbol derecho

template<class T>
int BiTree<T>::leafcount(BiNode<T>* root){  
	int number=0;  
	if (root==NULL)   
		number=0;  
	else if(root->lchild==NULL && root->rchild==NULL)   
		number=1;  
	else      
		number=leafcount(root->lchild)+leafcount(root->rchild);  
	return number; 
}

Calcule la altura
del árbol Definición de la altura: max ( la altura del subárbol izquierdo y la altura del subárbol derecho) El
análisis del algoritmo +1
comienza desde el nodo raíz, si root == NULL, la altura es 0; de lo contrario, la altura del subárbol izquierdo se calcula por separado ; La altura del subárbol derecho; return max (la altura del subárbol izquierdo, la altura del subárbol derecho) +1

template<typename T>
int BiTree<T>::cal_height(BiTreeNode<T> * root){  
	int lheight=0,rheight=0;  
	if (root==0)    
		return 0;
	lheight=cal_height(root->lchild);
	rheight=cal_height(root->rchild);
	if (lheight>rheight)
		return lheight+1;
	else
		return rheight+1; 
}

Genere la expresión infija y agregue los paréntesis correspondientes para recorrer la
idea básica
en orden.
Antes de atravesar el subárbol izquierdo en el orden medio, generar el paréntesis izquierdo
Después de atravesar el subárbol derecho, generar el paréntesis derecho.
Si atraviesa los subárboles izquierdo y derecho del nodo hoja, no generar paréntesis.
Si atraviesa los subárboles izquierdo y derecho del nodo raíz, no generar paréntesis (de lo contrario, Obtendrá una expresión de la forma (a + b))

void BiTree<T>::In_Expression(BiNode<T>* root){  
	if(root){       
		if(root!=this->root&&root->lchild!=0&&root->rchild!=0)               
			cout<<"(";     
		In_Expression(root->lchild);     
		cout<<root->data;        
		In_Expression(root->rchild);      
		if(root!=this->root&&root->lchild!=0&&root->rchild!=0)    	
			cout<<")";  
	}   
}

La forma del árbol binario de salida girada 90 grados en sentido antihorario
se atraviesa en el orden de derecha a izquierda;
cada línea genera un nodo;
sangrado de acuerdo con el nivel del nodo.

template<class T>
void BiTree<T>::Left_Rotate(BiNode<T>* root,int level){  
	if(root){   
		Left_Rotate(root->rchild, level+1);   
		for(int i=0;i<level;i++)
			cout<<"\t";   
		cout<<root->data<<endl;   
		Left_Rotate(root->lchild, level+1);  
	} 
}

Calcular el ancho del árbol binario El
llamado ancho se refiere al número total de nodos en la capa con el mayor número de nodos en cada capa del árbol binario.
Idea básica : realizar mediante el uso de la capa transversal.

struct q_element{ BiNode * root;  int level;}; 
int BiTree::Width(){  
	queue<struct q_element> q;  
	int num[100]={0,1};  
	q_element s,child;  
	BiNode *root;  
	root=this->root;  
	if(root==NULL)   
		return 0;
	s.root=root;
	s.level=1;
	q.push(s);
	while(!q.empty()){   
		s=q.front();   
		if(s.root->lchild){    
			num[s.level+1]++;    
			child.root=s.root->lchild;    
			child.level=s.level+1;    
			q.push(child);   
		}
		if(s.root->rchild){    
			num[s.level+1]++;    
			child.root=s.root->rchild;    
			child.level=s.level+1;    
			q.push(child);   
		}   
		q.pop();  
	}
	int max=0,i=1;  
	while(num[i]>0){   
		if(max<num[i])    
		max=num[i];   
		i++;  
	}    
	return max; 
}