特征
1.左子树上所有结点的值均小于或等于它的根结点的值
2.右子树上所有结点的值均大于或等于它的根结点的值。
3.左、右子树也分别为二叉排序树。
如下就是一棵典型的二叉查找树
因为查找使用二分查找法，所以查询时间复杂度是 O(lg2)
操作
二叉树的操作也就是增删查、遍历
查找就是二分查找。增添节点和删除节点的时候，要保持二叉树的性质。
遍历分为前序遍历(preorder travel)、中序遍历(inorder travel)、后续遍历(postorder travel)
前序遍历就是根节点第一个被遍历，按照“中左右”顺序，子树也按照这个顺序。中序按照“左中右”顺序。后续按照“左右中”顺序。
可以看到，前序就是根节点第一个被遍历，中序就是根节点在中间被遍历，后续就是根节点最后被遍历。都是针对根节点的。
通过前序+中序、后序+中序 可以还原一棵树。
比如上面这棵树，前序遍历：3102645，中序遍历：0123465
通过前序可以看到3是根节点，再看中序，3前面的 012 就是左子树，3后面的 456 就是右子树。继续看前序，1是左子树的根节点，6是右子树的根节点...依次类推，递归下去。
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <stack>
#include <list>
#include <queue>
#include <iostream>
enum EColor
{
WHITE = 0,
BLACK,
};
template <typename T>
struct stTreeNode
{
T d;
int color;
struct stTreeNode *left, *right;
stTreeNode(T data):d(data),color(WHITE),left(NULL),right(NULL) {}
};
template <typename T>
class CTree
{
public:
typedef T value_type;
typedef T& reference;
typedef T* pointer;
typedef stTreeNode<T> node_type;
typedef node_type* node_pointer;
CTree():root(NULL){}
CTree(const pointer arr, int len);
void insert(value_type data);
void del(value_type data);
node_pointer find(value_type data);
bool empty() {return root == NULL;};
int height();
void preorderTravel();
void inorderTravel();
void postorderTravel();
void layerTravle();
private:
node_pointer root;
void _insert(node_pointer *root, value_type data);
int _height(node_pointer root);
};
template <typename T>
CTree<T>::CTree(const CTree<T>::pointer arr, int len)
{
root = NULL;
for (int i = 0; i < len; ++i)
{
_insert(&root, arr[i]);
}
}
template <typename T>
void CTree<T>::_insert(CTree<T>::node_pointer *root, CTree<T>::value_type data)
{
if (*root == NULL)
{
*root = new CTree<T>::node_type(data);
}
else if (data > (*root)->d)
{
_insert(&(*root)->right, data);
}
else
{
_insert(&(*root)->left, data);
}
}
template <typename T>
void CTree<T>::insert(CTree<T>::value_type data)
{
_insert(&this->root, data);
}
template <typename T>
typename CTree<T>::node_pointer CTree<T>::find(CTree<T>::value_type data)
{
CTree<T>::node_pointer tmp = root;
while (tmp != NULL)
{
if (tmp->d == data)
{
return tmp;
}
else if (data > tmp->d)
{
tmp = tmp->right;
}
else
{
tmp = tmp->left;
}
}
return tmp;
}
template <typename T>
void CTree<T>::del(CTree<T>::value_type data)
{
CTree<T>::node_pointer parent = root;
CTree<T>::node_pointer tmp = root;
int left = -1;
while (tmp != NULL && tmp->d != data)
{
parent = tmp;
if (data > tmp->d)
{
tmp = tmp->right;
left = 0;
}
else
{
tmp = tmp->left;
left = 1;
}
}
if (!tmp)
{
return;
}
// 要删除的节点没有左子树
if (!tmp->left)
{
if (left)
{
parent->left = tmp->right;
}
else
{
parent->right = tmp->right;
}
}
else
{
CTree<T>::node_pointer cur = tmp;
parent = tmp;
tmp = tmp->left;
while (tmp->right != NULL)
{
parent = tmp;
tmp = tmp->right;
}
cur->d = tmp->d;
if (parent->left == tmp)
{
parent->left = tmp->left;
}
else
{
parent->right = tmp->left;
}
delete tmp;
}
}
template <typename T>
void CTree<T>::preorderTravel()
{
std::stack<CTree<T>::node_pointer, std::list<CTree<T>::node_pointer> > S;
if (root)
{
S.push(root);
}
while (!S.empty())
{
CTree<T>::node_pointer node = S.top();
std::cout << node->d << " ";
S.pop();
if (node->right)
{
S.push(node->right);
}
if (node->left)
{
S.push(node->left);
}
}
std::cout << std::endl;
}
template <typename T>
void CTree<T>::inorderTravel()
{
std::stack<CTree<T>::node_pointer, std::list<CTree<T>::node_pointer> > S;
if (root)
{
S.push(root);
}
while (!S.empty())
{
CTree<T>::node_pointer node = S.top();
if (node->left && node->left->color == WHITE)
{
S.push(node->left);
}
else
{
std::cout << node->d << " ";
node->color = BLACK;
S.pop();
if (node->right)
{
S.push(node->right);
}
}
}
std::cout << std::endl;
}
template <typename T>
void CTree<T>::postorderTravel()
{
std::stack<CTree<T>::node_pointer, std::list<CTree<T>::node_pointer> > S;
if (root)
{
S.push(root);
}
while (!S.empty())
{
CTree<T>::node_pointer node = S.top();
int nextTra = 1;
if (node->right && node->right->color == WHITE)
{
S.push(node->right);
nextTra = 0;
}
if (node->left && node->left->color == WHITE)
{
S.push(node->left);
nextTra = 0;
}
if (nextTra)
{
std::cout << node->d << " ";
node->color = BLACK;
S.pop();
}
}
std::cout << std::endl;
}
template <typename T>
void CTree<T>::layerTravle()
{
std::queue<CTree<T>::node_pointer, std::list<CTree<T>::node_pointer> > Q;
if (root)
{
Q.push(root);
}
while (!Q.empty())
{
CTree<T>::node_pointer node = Q.front();
std::cout << node->d << " ";
Q.pop();
if (node->left)
{
Q.push(node->left);
}
if (node->right)
{
Q.push(node->right);
}
}
std::cout << std::endl;
}
template <typename T>
int CTree<T>::_height(CTree<T>::node_pointer root)
{
if (root == NULL)
{
return 0;
}
int lh = _height(root->left);
int rh = _height(root->right);
return lh > rh ? lh + 1 : rh + 1;
}
template <typename T>
int CTree<T>::height()
{
return _height(root);
}
int main()
{
int arr[] = {6,3,4,1,3,8,9,7,6,0,2};
int len = sizeof(arr)/sizeof(int);
CTree<int> tree(arr, len);
tree.preorderTravel();
tree.postorderTravel();
tree.layerTravle();
printf("%d
", tree.height());
return 0;
}