二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”和“右子树”。二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2^（i - 1）个结点；深度为k的二叉树至多有2^k - 1个结点。由于树的定义是递归实现的，所以在进行二叉树的前序、中序和后序遍历可通过递归实现，但也可通过非递归的栈来实现，二叉树的层次遍历可通过队列实现。
让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：域名注册、虚拟主机、营销软件、网站建设、黄岛网站维护、网站推广。
下面我对二叉树及前序、中序、后序遍历二叉树等方法进行实现
例如二叉树:
测试用例：
int arrary[10] = {1,2,3,'$','$',4,'$','$',5,6};
arrary为上图所示二叉树，通过前序存储的，'$'表示非法值，即没有结点
二叉树的结构：
template
struct BinaryTreeNode
{
BinaryTreeNode* _left;
BinaryTreeNode* _right;
T _data;
BinaryTreeNode();
BinaryTreeNode(const T& x);
};
template
class BinaryTree
{
typedef BinaryTreeNode Node;
public:
BinaryTree();
BinaryTree(const T* a, size_t size, const T& invalid);
BinaryTree(const BinaryTree& t);
BinaryTree& operator=(BinaryTree t);
~BinaryTree();
void PrevOrder();//前序遍历-递归
void InOrder();//中序遍历-递归
void PostOrder();//后序遍历-递归
void PrevOrder_NonR();//前序遍历-非递归
void InOrder_NonR();//中序遍历-非递归
void PostOrder_NonR();//后序遍历-非递归
void LevelOrder();//层次遍历
size_t Size();//结点个数
size_t Depth();//树的深度
size_t LeafSize();//叶子结点个数
size_t GetkLevel();//第k层结点个数
protected:
Node* _CreateTree(const T* a, size_t size, size_t& index, const T& invalid);//树的建立
Node* _CopyTree(Node* t);//复制树
void _Distory(Node* root);//清空结点，先释放子树，再释放根结点
void _PrevOrder(Node* root);//前序遍历
void _InOrder(Node* root);//中序遍历
void _PostOrder(Node* root);//后序遍历
size_t _Size(Node* root);//结点个数
size_t _Depth(Node* root);//树的深度
//size_t _LeafSize(Node* root);//叶子结点个数
size_t _LeafSize(Node* root,size_t& size);//叶子结点个数
//size_t _GetkLevel(int k, Node* root);//第k层结点个数
size_t _GetkLevel(int k, Node* root, int& size, int level);//第k层结点个数
private:
Node* _root;// BinaryTreeNode* _root;
};
二叉树的构造、拷贝构造、赋值运算和析构的实现，由于二叉树存在左子树和右子树，故用递归实现其功能，具体实现如下：
template
BinaryTreeNode::BinaryTreeNode()
:_left(NULL)
, _right(NULL)
, _data(0)
{}
template
BinaryTreeNode::BinaryTreeNode(const T& x)
: _left(NULL)
, _right(NULL)
, _data(x)
{}
template
BinaryTree::BinaryTree()
:_root(NULL)
{}
template
BinaryTree::~BinaryTree()
{
_Distory(_root);
}
template
void BinaryTree::_Distory(Node* root)//清空结点，先释放子树，再释放根结点
{
if (root == NULL)
{
return;
}
if (root->_left)//递归释放子结点
{
_Distory(root->_left);
}
if (root->_right)
{
_Distory(root->_right);
}
delete root;
root = NULL;
}
template
BinaryTree::BinaryTree(const T* a, size_t size, const T& invalid)
{
size_t index = 0;//标记数组下标
_root = _CreateTree(a, size, index, invalid);
}
template
BinaryTreeNode* BinaryTree::_CreateTree(const T* a, size_t size, size_t& index, const T& invalid)//树的建立
{
Node* root = NULL;
if (index < size && a[index] != invalid)//indx_left = _CreateTree(a, size, ++index, invalid);//左子树递归
root->_right = _CreateTree(a, size, ++index, invalid);//右子树递归
}
return root;
}
template
BinaryTree::BinaryTree(const BinaryTree& t)
{
_root = _CopyTree(t._root);
}
template
BinaryTreeNode* BinaryTree::_CopyTree(Node* t)//此处的返回类型不能用Node表示
{
Node* root = NULL;
if (t != NULL)
{
root = new Node(t->_data);
root->_left = _CopyTree(t->_left);
root->_right = _CopyTree(t->_right);
}
return root;
}
template
BinaryTree& BinaryTree::operator=(BinaryTree t)//现代写法
{
if (this != &t)
{
BinaryTree tmp = t;
swap(_root, tmp._root);
}
return *this;
}
前序遍历(先根遍历)：(1)先访问根节点；(2)前序访问左子树；(3)前序访问右子树.【1 2 3 4 5 6】
下面分别用递归和非递归两种方法实现。
二叉树的递归实现前序遍历
//递归实现
template
void BinaryTree::PrevOrder()//前序遍历(先根结点)
{
_PrevOrder(_root);
}
template
void BinaryTree::_PrevOrder(Node* root)
{
if (root == NULL)
{
return;
}
cout << root->_data << " ";
_PrevOrder(root->_left);
_PrevOrder(root->_right);
}
二叉树的非递归实现前序序列，利用栈实现。
由于栈是后进先出，对于二叉树的前序遍历先访问左子树后访问右子树，故右结点比左结点先进栈
//非递归实现（利用栈实现）
template
void BinaryTree::PrevOrder_NonR()//前序遍历-非递归
{
stack s;
if (_root)
{
s.push(_root);
}
while (!s.empty())
{
Node* top = s.top();//访问栈顶元素
cout << top->_data << " ";
s.pop();
//右结点比左结点先进栈
if (top->_right)
{
s.push(top->_right);
}
if (top->_left)
{
s.push(top->_left);
}
}
cout << endl;
}
中序遍历：(1)中序访问左子树；(2)访问根节点；(3)中序访问右子树.【3 2 4 1 6 5】
下面分别用递归和非递归两种方法实现
二叉树的递归实现中序序列
template
void BinaryTree::InOrder()//中序遍历（中根结点）
{
_InOrder(_root);
}
template
void BinaryTree::_InOrder(Node* root)
{
if (root == NULL)
{
return;
}
_InOrder(root->_left);
cout << root->_data << " ";
_InOrder(root->_right);
}
二叉树的非递归实现中序序列
//非递归实现（利用栈实现）
template
void BinaryTree::InOrder_NonR()//中序遍历-非递归
{
if (_root == NULL)
{
return;
}
stack s;
Node* cur = _root;
while (cur || !s.empty())
{
//压一棵树的左结点，直到最左结点
while (cur)
{
s.push(cur);
cur = cur->_left;
}
if (!s.empty())
{
Node* top = s.top();
cout << top->_data << " ";
s.pop();
cur = top->_right;//使cur指向最左结点top的右结点
}
}
cout << endl;
}
后序遍历(后根遍历)：(1)后序访问左子树；(2)后序访问右子树；(3)访问根节点.【3 4 2 6 5 1】
下面分别用递归和非递归两种方法实现
二叉树的递归实现后序序列
//递归实现
template
void BinaryTree::PostOrder()//后序遍历（后根结点）
{
_PostOrder(_root);
}
template
void BinaryTree::_PostOrder(Node* root)//后序遍历
{
if (root == NULL)
{
return;
}
_PostOrder(root->_left);
_PostOrder(root->_right);
cout << root->_data << " ";
}
//非递归实现（利用栈实现）
二叉树的非递归实现后序序列
template
void BinaryTree::PostOrder_NonR()//后序遍历-非递归
{
if (_root == NULL)
{
return;
}
stack s;
Node* cur = _root;
Node* prev = NULL;
while (cur || !s.empty())
{
//压一棵树的左结点，直到最左结点
while (cur)
{
s.push(cur);
cur = cur->_left;
}
Node* top = s.top();
if (top->_right == NULL || top->_right == prev)
{
cout << top->_data << " ";
s.pop();
prev = top;
}
else//当未访问过栈顶的右子树，则继续右子树的访问
{
cur = top->_right;
}
cout << endl;
}
}
层序遍历：一层层节点依次遍历。【1 2 5 3 4 6】
下面用非递归方法实现，利用队列进行访问。
//递归实现
template
void BinaryTree::LevelOrder()//层次遍历,通过队列实现
{
queue q;//建立队列存放Note*类型值
if (_root != NULL)
{
q.push(_root);
}
while (!q.empty())
{
Node* front = q.front();
cout << front->_data << " ";//访问队头
q.pop();//队头出队列
if (front->_left != NULL)//存在左或右结点入队列
{
q.push(front->_left);
}
if (front->_right != NULL)
{
q.push(front->_right);
}
}
cout << endl;
}
求树的结点个数，递归实现：
template
size_t BinaryTree::Size()//结点个数
{
return _Size(_root);
}
template
size_t BinaryTree::_Size(Node* root)
{
if (root == NULL)
{
return 0;
}//root不为0，则Size+1
return _Size(root->_left) + _Size(root->_right) + 1;
}
求树的深度，递归实现：
template
size_t BinaryTree::Depth()//树的深度
{
return _Depth(_root);
}
template
size_t BinaryTree::_Depth(Node* root)
{
if (root == NULL)
{
return 0;
}
size_t LeftDepth = _Depth(root->_left);
size_t RightDepth = _Depth(root->_right);
if (LeftDepth > RightDepth)//root不为0，则深度+1
{
return LeftDepth + 1;
}
else
{
return RightDepth + 1;
}
}
求树的叶子结点个数，递归实现：
//方法一
template
size_t BinaryTree::LeafSize()//叶子结点个数
{
return _LeafSize(_root);
}
template
size_t BinaryTree::_LeafSize(Node* root)
{
if (root == 0)
{
return 0;
}
if (root->_left == 0 && root->_right == 0)
{
return 1;
}
return _LeafSize(root->_left) + _LeafSize(root->_right);
}
//方法二:在LeafSize中定义_size表示叶子结点个数
template
size_t BinaryTree::LeafSize()//叶子结点个数
{
size_t _size = 0;
return _LeafSize(_root, _size);
}
template
size_t BinaryTree::_LeafSize(Node* root, size_t& size)
{
if (root == 0)
{
return 0;
}
if (root->_left == 0 && root->_right == 0)
{
++size;
return size;
}
_LeafSize(root->_left, size);
_LeafSize(root->_right, size);
return size;
}
二叉树中第k层结点的个数，递归实现：
//方法一
template
size_t BinaryTree::GetkLevel(int k)
{
assert(k>0);
return _GetkLevel(k, _root);
}
template
size_t BinaryTree::_GetkLevel(int k, Node* root)//第k层结点个数
{
if (root == NULL)
{
return 0;
}
if (k == 1)//利用递归使k递减，k==1结束
{
return 1;
}
size_t size1 = _GetkLevel(k - 1, root->_left);
size_t size2 = _GetkLevel(k - 1, root->_right);
return size1 + size2;
}
//方法二:在GetkLevel中定义size表示第k层结点个数
template
size_t BinaryTree::GetkLevel(int k)
{
assert(k > 0);
int size = 0;//size为二叉树第level层结点个数
int level = 1;//第level层
return _GetkLevel(k, _root, size, level);
}
template
size_t BinaryTree::_GetkLevel(int k, Node* root, int& size, int level)//第k层结点个数
{
if (root == NULL)
{
return 0;
}
if (level == k)
{
++size;
return size;
}
_GetkLevel(k, root->_left, size, level+1);
_GetkLevel(k, root->_right, size, level+1);
return size;
}
网页标题：递归与非递归实现二叉树
文章起源：
http://jkwzsj.com/article/pjcoss.html
