经典二叉树面试题

#include <assert.h>
#include <queue>

template <class T>
struct BinaryTreeNode
{
T  _data;
BinaryTreeNode<T>* _left;
BinaryTreeNode<T>* _right;
BinaryTreeNode(const T& x)
:_data(x)
, _left(NULL)
, _right(NULL)
{}
};

template <class T>
class BinaryTree
{
public:
typedef BinaryTreeNode<T> Node;
//无参构造函数
BinaryTree()
:_root(NULL)
{}

//构造函数
BinaryTree(const T* a, size_t size, const T& invalid)
{
assert(a);
size_t index = 0;
_root = CreatTree(a, size, invalid, index);
}

//拷贝构造
BinaryTree(const BinaryTree<T>& b)
{
_root = _copy(b._root);
}

//析构函数
~BinaryTree()
{
if (NULL != _root)
{
Destroy(_root);
_root = NULL;
}
}

//层序遍历打印
void LevelOrder()
{
cout << "层序遍历:";
_levelorder(_root);
cout << endl;
}

//求叶子节点的个数
size_t GetLeafSize()
{
cout << "叶子节点的个数:";
return _GetLeafSize(_root);
}

//求第K层节点的个数
size_t GetKLevelSize(size_t k)
{
cout << "第"<<k<<"层节点：";
return _GetKLevelSize(_root, k);
}

//求二叉树的高度
size_t Depth()
{
cout << "树的深度：";
return _Depth(_root);
}

protected:
//按照先序遍历递归建树,index传引用
Node* CreatTree(const T* a, size_t size, const T& invalid, size_t& index)
{
assert(a);
Node* root = NULL;
if (a[index] != invalid && index < size)
{
root = new Node(a[index]);
root->_left = CreatTree(a, size, invalid, ++index);
root->_right = CreatTree(a, size, invalid, ++index);
}
return root;
}

//使用队列，层序遍历打印树的各个节点
void _levelorder(Node* root)
{
queue<Node* > q;
if (root)
{
q.push(root);
}
while (!q.empty())
{
Node* front = q.front();
q.pop();
cout << front->_data << " ";
if (front->_left)
{
q.push(front->_left);
}
if (front->_right)
{
q.push(front->_right);
}
}
}

//拷贝
Node* _copy(Node* root)
{
Node* tmp = NULL;

if (root)
{
tmp = new Node(root->_data);
tmp->_left = _copy(root->_left);
tmp->_right = _copy(root->_right);
}
return tmp;
}

//递归释放空间
void Destroy(Node* root)
{
//用后续遍历访问方式释放空间
if (root)
{
Destroy(root->_left);
Destroy(root->_right);
delete root;
root = NULL;
}
}

//求叶子节点
size_t _GetLeafSize(Node* root)
{
if (root == NULL)
return 0;
if (root->_left == NULL&&root->_right == NULL)
{
return 1;
}
else
{
return _GetLeafSize(root->_left) + _GetLeafSize(root->_right);
}
}

//求第k层节点个数
size_t _GetKLevelSize(Node* root, size_t k)
{
assert(k > 0);
size_t count = 0;
if (NULL == root)
return 0;
if (k == 1)
count++;
else
{
count = _GetKLevelSize(root->_left, k - 1) + _GetKLevelSize(root->_right, k - 1);
}
return count;
}

//求树的深度
size_t _Depth(Node* root)
{
if (root == NULL)
return 0;
else
{
return _Depth(root->_left) > _Depth(root->_right) ? (_Depth(root->_left) + 1) : (_Depth(root->_right) + 1);
}
}
private:
N
4000
ode* _root;
};

void TestBinaryTree()
{
int arr[] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6, '#', '#', '#' };
size_t size = sizeof(arr) / sizeof(arr[0]);
BinaryTree<int> bt(arr, size, '#');
BinaryTree<int> b1(bt);
//bt.~BinaryTree();
bt.LevelOrder();
cout << bt.Depth() << endl;;
cout << bt.GetLeafSize() << endl;
cout << bt.GetKLevelSize(2) << endl;
}