二叉树遍历

  二叉树是很有用的一种数据结构，遍历则是其基本操作，这里列出实是保证完整性。几个备用的结构定义和函数：
//二叉树节点定义
class TreeNodeElement
{
       public:
              TreeNodeElement();
 
              TreeNodeElement(int value);
            
              TreeNodeElement(int value,TreeNodeElement* l,TreeNodeElement* r);
 
              ~TreeNodeElement();
 
       private:
       public:
              int _value;
 
              TreeNodeElement* _l;
 
              TreeNodeElement* _r;
};
 
typedef TreeNodeElement* TreeNode;
//递归实现（visit）
void Visit(TreeNode node)
{
       cout<<node->_value<<" ";
}
       二叉树中序遍历的递归和非递归实现：
//递归遍历
void BinRetriveATree(TreeNode root,void (* visit)(TreeNode))
{
       if (root)
       {
              BinRetriveATree(root->_l,visit);
              (*visit)(root);
              BinRetriveATree(root->_r,visit);
       }
     
}
//非递归遍历，添加#include <stack>
void BinRetriveATreeWithoutRecurve(TreeNode root,void (* visit)(TreeNode))
{
       stack<TreeNode> tree;
 
       while ((root != NULL) || (!tree.empty()))
       {
              while (root != NULL)
              {
                     tree.push(root);
 
                     root = root->_l;
              }
 
              if (!tree.empty())
              {
                     root = tree.top();
 
                     tree.pop();
 
                     visit(root);
                   
                     root = root->_r;   //转到右子树
 
              }
       }
}

二叉树前序遍历的递归和非递归实现：

//递归遍历

void PreRetriveATree(TreeNode root,void (* visit)(TreeNode))

{

       if (root)

       {

              (*visit)(root);

 

              PreRetriveATree(root->_l,visit);

 

              PreRetriveATree(root->_r,visit);

       }

}

//非递归遍历，添加#include <stack>

void PreRetriveATreeWithoutRecurve(TreeNode root,void (* visit)(TreeNode))

{

       stack<TreeNode> tree;

 

       TreeNode tmp = NULL;

 

       //根节点入栈

       tree.push(root);

 

       while (!tree.empty())

       {

              tmp = tree.top();

              tree.pop();

 

              (*visit)(tmp);

             

              if (tmp->_r != NULL)

              {

                     tree.push(tmp->_r);

              }

 

              if (tmp->_l != NULL)

              {

                     tree.push(tmp->_l);

              }

       }

}

二叉树是很有用的一种数据结构，遍历则是其基本操作，这里列出实是保证完整性。二叉树后序遍历的非递归遍历中当当前节点存在右子树的时候需要先遍历右子树，因此要对二叉树的节点定义中添加_tag域，标志当前节点右子树是否已经遍历，备用的结构定义和函数：

//二叉树节点定义

class TreeNodeElement

{

       public:

              TreeNodeElement();

 

              TreeNodeElement(int value);

             

              TreeNodeElement(int value,TreeNodeElement* l,TreeNodeElement* r);

 

              ~TreeNodeElement();

 

       private:

       public:

              int _value;

 

              TreeNodeElement* _l;

 

              TreeNodeElement* _r;

 

              bool _tag;

};

 

typedef TreeNodeElement* TreeNode;

//构造函数的定义，前序和中序中相似，只是不学要_tag域

TreeNodeElement::TreeNodeElement()

{

       _value = -1;

 

       _l = NULL;

 

       _r = NULL;

 

       _tag = false;

}

 

TreeNodeElement::TreeNodeElement(int value)

{

       _value = value;

 

       _l = NULL;

 

       _r = NULL;

 

       _tag = false;

}

 

TreeNodeElement::TreeNodeElement(int value,TreeNodeElement* l,TreeNodeElement* r)

{

       _value = value;

 

       _l = l;

 

       _r = r;

 

       _tag = false;

}

 

TreeNodeElement::~TreeNodeElement()

{

       delete _l;

              delete _r;

}

//递归实现（visit）

void Visit(TreeNode node)

{

       cout<<node->_value<<" ";

}

       二叉树后序遍历的递归和非递归实现：

//递归遍历

void PostRetriveATree(TreeNode root,void (* visit)(TreeNode))

{

       if (root)

       {

              PostRetriveATree(root->_l,visit);

              PostRetriveATree(root->_r,visit);

              (*visit)(root);

       }

}

//非递归遍历，添加#include <stack>

void PostRetriveATreeWithoutRecurve(TreeNode root,void (* visit)(TreeNode))

{

       stack<TreeNode> tree;

 

       while ((root != NULL) || (!tree.empty()))

       {

              while (root != NULL)

              {

                     tree.push(root);

 

                     root = root->_l;

              }

 

              if (!tree.empty())

              {

                     root = tree.top();

 

                     if (root->_tag)  //可以访问

                     {

                            visit(root);

 

                            tree.pop();

                           

                            root = NULL; //第二次访问标志其右子树也已经遍历

                     }

                     else

                     {

                            root->_tag = true;

                            root = root->_r;

                     }

              }

       }

}

 

怎样从顶部开始逐层打印二叉树结点数据？请编程。这个题目实际上很简单，采用队列的方式很容易可以实现：

void HiberarchyRetriveATree(TreeNode root,void (* visit)(TreeNode))

{

       queue<TreeNode> tree;

 

       TreeNode tmp = NULL;

 

       tree.push(root);

 

       while (!tree.empty())

       {

              tmp = tree.front();

 

              tree.pop();

 

              (*visit)(tmp);

 

              if (tmp->_l != NULL)

                     tree.push(tmp->_l);

 

              if (tmp->_r != NULL)

                     tree.push(tmp->_r);

       }

}

这里用到节点访问的策略，简单可以实现为：

void Visit(TreeNode node)

{

       cout<<node->_value<<" ";

}