二叉树的基本操作，都使用递归：

//二叉树   class Node  {  public:      char data;      Node *left;      Node *right;      Node():data(' '),left(NULL),right(NULL){}      Node(char ch):data(ch),left(NULL),right(NULL){}  };      //广义表建立二叉树，输入：A(B(D,E(G,)),C(,F))*   void CreateBinTree(Node* & Root,char *str)  {      stack
     
       s;      Root=NULL;      Node* p=NULL,*t=NULL;      int k,i=0;      while(str[i])      {          switch(str[i])          {              case '(': s.push(p); k=1; break;              case ')': t=s.top(); s.pop(); break;              case ',': k=2; break;              default:              p=new Node(str[i]);              if(Root==NULL) Root=p;              else if(k==1)              {                  t=s.top(); t->left=p;              }              else              {                  t=s.top(); t->right=p;              }          }          ++i;      }  }    //递归先序遍历   void preOrderTraverse(Node *p)  {     if(p != NULL)     {         cout<
      
       data;         preOrderTraverse(p->left);         preOrderTraverse(p->right);     }  }    //求节点个数   int Size(Node* root)  {      if(root == NULL) return 0;      return 1 + Size(root->left) + Size(root->right);  }    //求树的高度   int TreeDepth(Node* t)  {      int hl,hr,h;      if(t != NULL)      {          hl = TreeDepth(t->left);          hr = TreeDepth(t->right);          h = hl>hr? hl:hr;          return h+1;      }      return 0;  }    //销毁二叉树   void freeTree(Node*& p)  {      if(p->left != NULL)          freeTree(p->left);      if(p->right != NULL)          freeTree(p->right);      delete(p);  }
      
     

二叉树的各种遍历：

//输出第level层的所有节点（从左到右），成功返回1   int PrintNodeAtLevel(Node* root,int level)  {      if(!root || level<0)  return 0;      if(level==0)      {          cout<
     
      data<<" ";          return 1;      }      return PrintNodeAtLevel(root->left,level-1)+PrintNodeAtLevel(root->right,level-1);  }    //层次遍历二叉树，使用树的高度   void PrintNodeByLevel(Node* root,int depth)  {      for(int level=0; level
      
        q;      if(t==NULL) return;      q.push(t);      while(!q.empty())      {          Node* p=q.front();          q.pop();          cout<
       
        data<<" ";          if(p->left) q.push(p->left);          if(p->right) q.push(p->right);      }  }    //层次遍历二叉树   void LevelOrder(Node* root)  {      if(root==NULL) return;      vector
        
          v;      v.push_back(root);      int cur=0;      int last=1;      while(cur
         
          data<<" ";              if(v[cur]->left) v.push_back(v[cur]->left);              if(v[cur]->right) v.push_back(v[cur]->right);              cur++;          }          cout<
          
            s; Node* p=NULL; if(root==NULL) return; s.push(root); while(!s.empty()) { p=s.top(); s.pop(); cout<
           
            data<<" "; if(p->right) s.push(p->right); if(p->left) s.push(p->left); } } //非递归先序遍历树 void preOrder(Node* t) { stack
            
              s; Node* p=t; while (p!=NULL || !s.empty()) { while (p!=NULL) //遍历左子树 { cout<
             
              data<<" "; s.push(p); p=p->left; } if (!s.empty()) //通过下一次循环中的内嵌while实现右子树遍历 { p=s.top(); s.pop(); p=p->right; } } } /*非递归中序遍历树算法：从根节点开始，只要当前节点存在，或者栈不为空，则重复下面操作： (1)如果当前节点存在，则进栈并走左子树。 (2)否则退栈并访问，然后走右子树。 */ void inOrder(Node* t) { stack
              
                s; Node* p=t; while(p||!s.empty()) { if(p) { s.push(p); p=p->left; } else { p=s.top();s.pop(); cout<
               
                data<<" "; p=p->right; } } } /*非递归后序遍历树：后序遍历，先遍历到的结点最后访问 用两个栈，一个栈用来遍历，另一个栈保存遍历到的结点，最后一起出栈，就是后序遍历结果 */ void postOrder(Node* root) { stack
                
                  sTraverse,sVisit; Node* p=NULL; if(root==NULL) return; sTraverse.push(root); while(!sTraverse.empty()) { p=sTraverse.top(); sTraverse.pop(); sVisit.push(p); if(p->left) sTraverse.push(p->left); if(p->right) sTraverse.push(p->right); } while(!sVisit.empty()) { p=sVisit.top(); sVisit.pop(); cout<
                 
                  data<<" "; } } /*非递归后序遍历树算法：从根节点开始，只要当前节点存在，或者栈不为空，则重复下面操作： (1)从当前节点开始，进栈并走左子树，直到左子树为空。 (2)如果栈顶节点的右子树为空，或者栈顶节点的右孩子为刚访问过的节点， 则退栈并访问，然后置当前节点指针为空。 (3)否则走右子树。 */ void postOrder(Node* t) { Node *p,*q; stack
                  
                    s; p=t; q=NULL; while(p!=NULL||!s.empty()) { while(p!=NULL) { s.push(p); p=p->left; } if(!s.empty()) { p=s.top(); if((p->right==NULL) || (p->right==q)) { cout<
                   
                    data<<" "; q=p; s.pop(); p=NULL; } else p=p->right; } } } /*根节点到r节点的路径： 后序遍历时访问到r节点时，栈中的所有的节点均为r节点的祖先，这些祖先构成根节点到r节点的路径 */ void nodePath(Node* root,Node* r) { Node *p,*q; stack
                    
                      s; p=root; q=NULL; //q保存刚访问过的节点 while(p!=NULL||!s.empty()) { while(p!=NULL) { s.push(p); p=p->left; } if(!s.empty()) { p=s.top(); if( (p->right==NULL) || (p->right==q) ) { if(p==r) { while(!s.empty()) { Node* t=s.top(); s.pop(); cout<
                     
                      value<<" "; } return; } else { q=p; s.pop(); p=NULL; } } else p=p->right; } } }