C++实现利用（前序和中序生成二叉树）以及（二叉树的镜像）

#include<iostream>
#include<string.h>
#include<stack>
using namespace std;
typedef struct BTree
{
    int val;
    struct BTree *left,*right;
}BTree;
/*二叉树的类，包含着操作二叉树的各种方法*/
class Tree
{
    public:
    BTree *create_node(int level,string pos);
    void PreOrder(BTree *t);  //先序遍历
    void InOrder(BTree *t);  //中序遍历
    void PostOrder(BTree *t);  //后序遍历
    void NonRecursivePreOrder(BTree*t); //非递归前序遍历
    void NonRecursiveInOrder(BTree*t);  //非递归中序遍历
    void NonRecursivePostOrder(BTree*t);//非递归后序遍历
    BTree* PreOrder_and_INorder_RemakeTree(int *startPreorder,int *endPreder,int *startInorder,int*endInorder);
    BTree *root;
};
 
/*用先序遍历的方法递归构造一课二叉树*/
BTree* Tree::create_node(int level,string pos)
{
    int data;
    BTree *node = new BTree;
    int a[]={,,,,,,,,,,,,,,,,,,};
    static int t=;
    cout<<"please enter data:level "<<level<<" "<<pos<<"--->值为:"<<a[t]<<endl;
       data=a[t++];
    if(data == )
    {
        return NULL;
    }
    node->val= data;
    node->left = create_node(level+,"left");
    node->right= create_node(level+,"right");
    return node;
}
 
void Tree::PreOrder(BTree *t)
{
    if(t)
    {
        cout<<t->val<<" ";;
        PreOrder(t->left);
        PreOrder(t->right);
    }
}
 
void Tree::InOrder(BTree *t)
{
    if(t)
    {
        InOrder(t->left);
        cout<<t->val<<" ";;
        InOrder(t->right);
    }
}
 
void Tree::PostOrder(BTree *t)
{
    if(t)
    {
        PostOrder(t->left);
        PostOrder(t->right);
        cout<<t->val<<" ";
    }
}
void Tree::NonRecursivePreOrder(BTree*t)
{
  if(t==NULL)
   return;
  stack<BTree*>s;
  BTree *p;
  p=t;
  while(p||!s.empty())
  {
   if(p)
   {
       cout<<p->val<<" ";
       s.push(p);
       p=p->left;
   }
   else{
       p=s.top();
       p=p->right;
       s.pop();
   }
  }
}
void Tree::NonRecursiveInOrder(BTree*t)
{
    if(t==NULL)
        return;
    stack<BTree*>s;
    BTree*p;
    p=t;
    while(p||!s.empty())
    {
        if(p)
        {
            s.push(p);
            p=p->left;
        }
        else
        {
            p=s.top();
            cout<<p->val<<" ";
            p=p->right;
            s.pop();
        }
    }
}
void Tree::NonRecursivePostOrder(BTree*t)
{
  if(t==NULL)
      return;
  stack<BTree*>s;
  BTree*p=t;
  BTree*r;
  while(p||!s.empty())
  {
      if(p)
      {
          s.push(p);
          p=p->left;
      }
      else
      {
          p=s.top();
          if(p->right&&p->right!=r)
          {
              p=p->right;
              s.push(p);
              p=p->left;
          }
          else
          {
              cout<<p->val<<" ";
              r=p;
              s.pop();
              p=NULL;
          }
      }
  }
 
}
BTree* Tree::PreOrder_and_INorder_RemakeTree(int *startPreorder,int *endPreorder,int *startInorder,int*endInorder)
{
  int rootValue=startPreorder[];
  BTree*root=new BTree;
   root->val=rootValue;
   root->left=NULL;
   root->right=NULL;
//　　　　　  在中序遍历中找根节点的值
   int*rootInorder=startInorder;
   while(rootInorder<=endInorder&&*rootInorder!=rootValue)
       rootInorder++;
   int leftLength=rootInorder-startInorder;
   int *leftPreorderEnd=startPreorder+leftLength;
   if(leftLength>)
   {
       root->left=PreOrder_and_INorder_RemakeTree(startPreorder+,leftPreorderEnd,startInorder,rootInorder-);
   }
   if(leftLength<endPreorder-startPreorder)
   {
       root->right=PreOrder_and_INorder_RemakeTree(leftPreorderEnd+,endPreorder,rootInorder+,endInorder);
   }
return root;
}
BTree* binary_tree_mirror(BTree*head)
{
    BTree*newHead=head;
    if(head==NULL)
        return NULL;
    if(head->left!=NULL&&head->right!=NULL)
    {
        BTree *p;
        p=head->left;
        head->left=head->right;
        head->right=p;
    }
    binary_tree_mirror(head->left);
    binary_tree_mirror(head->right);
    return newHead;
}
 
int main()
{
    Tree tree;
    tree.root = tree.create_node(,"root");
    cout<<"Pre"<<endl;
    tree.PreOrder(tree.root);
    cout<<endl;
    cout<<"非递归前序遍历"<<endl;
    tree.NonRecursivePreOrder(tree.root);
    cout<<endl;
    cout<<"In"<<endl;
    tree.InOrder(tree.root);
    cout<<endl;
    cout<<"非递归中序遍历"<<endl;
    tree.NonRecursiveInOrder(tree.root);
    cout<<endl;
    cout<<"Post"<<endl;
    tree.PostOrder(tree.root);
    cout<<endl;
    cout<<"非递归后序遍历"<<endl;
    tree.NonRecursivePostOrder(tree.root);
    int preNum[]={,,,,,,,,};
    int InNum[]={,,,,,,,,};
    BTree*root2;
    int *endPreorder=&preNum[];
    int *endInorder=&InNum[];
    root2=tree.PreOrder_and_INorder_RemakeTree(preNum,endPreorder,InNum,endInorder);
    cout<<endl;
    cout<<"用后序遍历测试用前序和中序生成的二叉树："<<endl;
     tree.PostOrder(root2);
     cout<<"二叉树的镜像为:"<<endl;
     BTree *newTree;
     newTree=binary_tree_mirror(root2);
     cout<<"镜像二叉树的后序遍历为:"<<endl;
     tree.PostOrder(newTree);
     return ;
}
二叉树的图：
　　　　　　　　　　                     (100)
                             (99)              (5)
                        (98)     (10)       (1)     (2)
                     (97)   (20)

结果：

please enter data:level  root--->值为:
please enter data:level  left--->值为:
please enter data:level  left--->值为:
please enter data:level  left--->值为:
please enter data:level  left--->值为:
please enter data:level  right--->值为:
please enter data:level  right--->值为:
please enter data:level  left--->值为:
please enter data:level  right--->值为:
please enter data:level  right--->值为:
please enter data:level  left--->值为:
please enter data:level  right--->值为:
please enter data:level  right--->值为:
please enter data:level  left--->值为:
please enter data:level  left--->值为:
please enter data:level  right--->值为:
please enter data:level  right--->值为:
please enter data:level  left--->值为:
please enter data:level  right--->值为:
Pre
 
非递归前序遍历
 
In
 
非递归中序遍历
 
Post
 
非递归后序遍历
 
用后序遍历测试用前序和中序生成的二叉树：
 
镜像二叉树的后序遍历为: