[] Estrutura de dados - natureza binária da interface comum

Em primeiro lugar, o conceito de uma árvore binária

Na ciência da computação, uma árvore binária cada nó tem no máximo duas subárvores de uma estrutura de árvore. Normalmente subárvore é chamado de "sub-árvore esquerda" (sub-árvore esquerda) e "subárvore direita" (sub-árvore direita), uma árvore binária é muitas vezes usado para implementar uma árvore de busca binária e uma pilha de binário. (Trecho da Enciclopédia Baidu)

1. Qual é a árvore binária completa?

Exceto para o último sem qualquer nó filho, todos os nós em cada camada tem dois nós filhos da árvore binária.

2. Qual é a árvore binária completa?

Uma árvore binária, apenas as duas camadas inferiores dos nós pode ser inferior a 2, eo nó de folha inferior concentrada em vários locais do lado esquerdo, de modo que uma árvore binária é chamada uma árvore binária completa.

3, que é a árvore de busca binária?

árvore de busca binária também é conhecido como uma árvore de busca binária. Seja x um nó em uma árvore de busca binária, x nó contém a chave palavras-chave, chave de valor de contagem nó de x é a chave [x]. Se y é um nó na subárvore esquerda de x é, a tecla [y] <= tecla [x], se y é um nó na subárvore direita de x, em seguida, a tecla [y]> = tecla [x]

Em uma árvore de busca binária:

(1) Se todos os nós deixados sub não está vazia, então o valor do sub esquerda, todos os nós são menos do que o valor da raiz.

(2) o sub-árvore direita de qualquer nó não está vazia, então a sub-árvore direita, todos os nós que são maiores do que o valor da raiz.

Esquerda (3) qualquer nó, respectivamente subárvore direita é a árvore de busca binária.

(4) não é igual a chave nó.

Em segundo lugar, a natureza da árvore binária

Propriedade 1 : o número de nós na árvore binária até i-th camada 2i-1 (i> = 1 )

Propriedade 2 : uma árvore binária de profundidade k no máximo 2k-1 nodos (k> = 1)

Propriedade 3 : A altura da árvore binária de n nós que compreendem, pelo menos, (log2N) 1

Propriedade 4 : Em qualquer uma árvore binária, se o número de nós terminais n0, o número de nós de grau 2 é N2, em seguida, n0 = n2 + 1

Em terceiro lugar, a interface binária comum

• Estrutura é definida:

struct TreeNode
{
		int val;
	TreeNode *left;
	TreeNode* right;
	TreeNode(int x):val(x),left(NULL),right(NULL)
	{}
};
 - 以下是先序遍历递归与非递归接口
 - 中序遍历的递归与非递归接口
 - 后序遍历的递归与非递归接口
 - 层次遍历二叉树
 - 求二叉树的深度递归与非递归
 - 判断一棵树是否为平衡二叉树

//先序遍历
//递归版本
void PreTraversal(vector<int> &v, TreeNode* root)
{
	if (!root)
		return;
	v.push_back(root);
	PreTraversal(v, root->left);
	PreTraversal(v, root->right);
}
//非递归版本
void PreTraversal(vector<int> &v, TreeNode* root)
{
	stack<TreeNode*> s;
	s.push(root);
	while (!s.empty())
	{
		TreeNode *cur = s.top();
		s.pop();
		if (temp)
		{
			v.push_back(cur->val);
			s.push(root->right);
			s.push(root->left);
		}
	}
}

//中序遍历  //左根右
void InorderTraversal(vector<int> &v, TreeNode* root)
{
	if (!root) return;
	InorderTraversal(v, root->left);
	v.push(root->val);
	InorderTraversal(v, root->right);
}

//非递归遍历
void InorderTraversal(vector<int> &v, TreeNode* root)
{
	TreeNode* cur = root;
	stack<TreeNode*> s;
	while (root||!s.empty())
	{
		while (root)
		{
			s.push(root);
			root = root->left;
		}
		TreeNode* cur = s.top();
		s.pop();
		v.push_back(cur->val);
		root = cur->right;
	}
}
//后序遍历
void PostorderTraversal(vector<int> &v, TreeNode* root)
{
	if (!root) return;
	PostorderTraversal(v, root->left);
	PostorderTraversal(v, root->right);
	v.push(root->val);
}
//非递归版本
void postOrderTraversal(vector<int> &store, TreeNode *root) {
	stack<TreeNode *> S;
	S.push(root);
	while (!S.empty()) {
		TreeNode *curr_node = S.top();
		S.pop();
		if (curr_node) {
			store.push_back(curr_node->val);
			S.push(curr_node->left);    //右孩子优先，所以左孩子先入栈
			S.push(curr_node->right);
		}
	}
	std::reverse(store.begin(), store.end());   //逆序列即为所求
	return;
}

//层次遍历
void LevelOrderTraversal(vector<int> &v, TreeNode *root)
{
	queue<TreeNode*> q;
	q.push(root);
	while (!q.empty())
	{
		TreeNode* ret = q->front();
		q.pop();
		if (ret)
		{
			v.push_back(ret->val);
			q.push(ret->_left);
			q.push(ret->right);
		}
	}
}

//二叉树的深度
int TreeDeepTh(TreeNode* root)
{
	//递归法
	return root ? 1 + max(TreeDeepth(root->left), TreeDeepth(root->right)):0;
}
//迭代法  用到层次遍历，层次就是我们的深度
int TreeDeepTh(TreeNode* root)
{
	if (!root)
	{
		return 0;
	}
	int depth = 0;
	queue<TreeNode*> q;
	q.push(root);
	while (!q.empty())
	{
		int length = q.size();
		++depth;
		while (length--)
		{
			TreeNode* ret = q->front();
			q.pop();
			if (ret)
			{
				v.push_back(ret->val);
				q.push(ret->_left);
				q.push(ret->right);
				length++;
			}
		}
		
	}
	return length;
}

//判断一棵树是否为平衡二叉树:平衡二叉树是指：它是一颗空树
//或者左右子树的高度差不超过1，并且左右子树都是一颗平衡二叉树
bool Isbalanced(TreeNode * root,int &Deepth)
{
	if (!root)
	{
		Deepth = 0;
		return true;
	}
	int left_depth, right_depth;
	if (Isbalanced(root->left, left_depth) && Isbalanced(root->right, right_depth))
	{
		int diff = left_depth - right_depth;
		if (diff <= 1 && diff >= -1)
		{
			Deepth = 1 + ((left_depth > right_depth) ? left_depth : right_depth);
			return true;
		}
	}
	return false;

}
bool IsBlancedTree(TreeNode* root)
{
	int Deepth = 0;
	return Isbalanced(root, Deepth);
}