Fortuna dejó Método basado class4- 8 Título conoce un árbol binario completo, el número de nodos que buscan

1. Título: Dado un árbol binario completo, encontrar el número de sus nodos. Requisitos: complejidad de tiempo es inferior a O (N), N es el número de nodos del árbol

2. Análisis

Puesto que el requisito es inferior al tiempo de complejidad O (N), el método no se puede usar para atravesar, considerar la naturaleza del árbol binario completo: la altura es de k, el número de nodos es 2 ^ k - 1. La solución completa sub-jamás árbol binario para el árbol binario completo y, a continuación, obtener rápidamente el número de nodos.
El número de cálculo nodo frontera izquierda, para obtener el H más profundo, atravesando el subárbol derecho del nodo actual, se determina si o llega a la última capa, si alcanza el último nivel es árbol binario completo por debajo de la izquierda, luego la recursión subárbol derecho: Pensamiento . Si no al subárbol derecho Altura - 1 árbol binario completo, a continuación, de forma recursiva el subárbol izquierdo.

EG
nodo actual ① es x, es el más profundo 4, izquierda y derecha sub-árbol ha alcanzado la más profunda 4, en el lado izquierdo del árbol binario completo, el nodo 2 ^ 3-1 = 7, 8 junto con el nodo superior.
② En este caso el cálculo de los nodos subárbol derecho, más 4, 3 no es el subárbol derecho a la más profunda, entonces el subárbol derecho del árbol binario completo. 1 -1 hecho +1 = ^ 2 2
③ Cálculo ,, nodo subárbol más a la izquierda 4, 3 es un subárbol derecho, entonces el subárbol derecho del árbol binario completo ^ 2 = 1 0 -1 1
último punto de la última izquierda ④, y finalmente alcanzado los retornos de nivel 1
⑤8 + + 1 = es 2 + 1 12
que se ven cada uno de descomposición si el lado derecho de llegar a lo más profundo, te faltan para el árbol binario completo, por el contrario, el árbol binario subárbol derecho está lleno. Sea cual sea el árbol binario completo lado, el nodo principal actual se calculará en el, y y 2 ^ l - 1, -1, offset.

código 3. núcleo

En la programación real, también será necesario que el árbol binario completo para registrar el número actual de capas con el fin de calcular el árbol binario historia completa.

(1) La función principal

El número de nodos de computación, el primer nodo está vacía devuelve directamente 0, el aire acondicionado no es una función de los nodos de computación

int nodeNum(Tree* head)
{
	if(head == NULL)
		return 0;
	return bs(head,1,most_level(head,1));
}

(2) Profundidad del árbol

//该节点在level层，计算此节点深度
int most_level(Tree *head,int level)
{
	while(head != NULL)
	{
		level++;
		head = head->left;
	}
	return level - 1;
}

(3) contar el número de nodo

subárbol derecho del extremo izquierdo profundidad y la profundidad total de la misma, dada árboles binarios completos, el número de cómputo nodos subárbol de forma recursiva derecha, si no el derecho de árbol binario completo (altura menor que la izquierda 1), cuente el número de nodo de la derecha, y la recursividad a continuación, izquierda .

int bs(Tree *head,int level,int h)
{
	if(level == h)//当前层为最后一层，只有一个节点（叶节点）
		return 1;
	if(most_level(head->right,level + 1) == h)//右子树最左深度和整体深度比较，子树需要level + 1
		//左树节点个数 2^(h - level) -1 + 当前节点个数1 再加上递归的右边的节点个数
		return (1 << (h - level)) + bs(head->right,level + 1,h);
	else
		//右树节点个数 2^(h - level -1) -1 + 当前节点个数1 加上递归的左边的节点个数
		//h - level -1是因为右树不满的情况下，高度比左树还要小1
		return (1 << (h - level - 1)) + bs(head->left,level + 1,h);
}

1 << xRepresenta 2 ^ x

4. El código completo

#include<iostream>
#include<queue>
using namespace std;

class Tree
{
public:
	int val;
	Tree *left;
	Tree *right;
	Tree(int x){
		this->val = x;
		this->left = NULL;
		this->right = NULL;
	}
};

int most_level(Tree *head, int level);
int bs(Tree *head,int level,int h);

int nodeNum(Tree* head)
{
	if(head == NULL)
		return 0;
	return bs(head,1,most_level(head,1));
}

int bs(Tree *head,int level,int h)
{
	if(level == h)//当前层为最后一层，只有一个节点（叶节点）
		return 1;
	if(most_level(head->right,level + 1) == h)//右子树最左深度和整体深度比较
		//左树节点个数 2^(h - level) -1 + 当前节点个数1 加上递归的右边的节点个数
		return (1 << (h - level)) + bs(head->right,level + 1,h);
	else
		//右树节点个数 2^(h - level -1) -1 + 当前节点个数1 加上递归的左边的节点个数
		//h - level -1是因为右树不满的情况下，高度比左树还要小1
		return (1 << (h - level - 1)) + bs(head->left,level + 1,h);
}

//该节点在level层，计算此节点深度
int most_level(Tree *head,int level)
{
	while(head != NULL)
	{
		level++;
		head = head->left;
	}
	return level - 1;
}

int main()
{
	Tree *head = new Tree(5);
	head->left = new Tree(3);
	head->left->left = new Tree(2);
	head->left->right = new Tree(4);
	head->right = new Tree(8);
	head->right->left = new Tree(6);
	head->right->right = new Tree(10);
	head->left->left->left= new Tree(7);

	
	cout<<nodeNum(head)<<endl;

	system("pause");
	return 0; 
}

5. Análisis de Complejidad

Recursive, ya que el lado del árbol siempre lleno, entonces cada necesidad capa única para atravesar un nodo, izquierda o derecha, un total requiere nodo actual atravesada O (logN), durante cada recorrido, la profundidad del árbol necesita Qiuzi, la complejidad todavía es O (logN), la complejidad global es O [(logN)] ^ 2