二叉树

#ifndef TREENODE_H
#define TREENODE_H

template<class NODETYPE> class Tree;

template<class NODETYPE>
class TreeNode{
      friend class Tree<NODETYPE>;
public:
       TreeNode(const NODETYPE &d)
       :leftPtr(0),data(d),rightPtr(0){}
       NODETYPE  getdata() const {return data;}
private:
        TreeNode<NODETYPE>*leftPtr;
        NODETYPE data;
        TreeNode<NODETYPE>*rightPtr;
};
#endif

 

#ifndef TREE_H
#define TREE_H

#include <iostream>
#include <cassert>
#include "treenode.h"

using std::endl;
using std::cout;
template <class NODETYPE>
class Tree{
      public:
             Tree();
             void insertNode(const NODETYPE&);
             void preOrderTraversal() const;
             void inOrderTraversal() const;
             void postOrderTraversal() const;
      private:
              TreeNode<NODETYPE> *rootPtr;
              void insertNodeHelper(
              TreeNode<NODETYPE>**,const NODETYPE&);
              void preOrderHelper(TreeNode<NODETYPE>*)const;
              void inOrderHelper(TreeNode<NODETYPE>*)const;
              void postOrderHelper(TreeNode<NODETYPE>*)const;
      
          };
template<class NODETYPE>
Tree<NODETYPE>::Tree(){rootPtr=0;}

template<class NODETYPE>
void Tree<NODETYPE>::insertNode(const NODETYPE&value)
{insertNodeHelper(&rootPtr,value);}

template<class NODETYPE>
void Tree<NODETYPE>::insertNodeHelper(
      TreeNode<NODETYPE>**ptr,const NODETYPE&value)
    {
    if (*ptr==0){
                 *ptr=new TreeNode<NODETYPE>(value);
                 assert(*ptr!=0);
                 }
    else
         if (value<(*ptr)->data)
         insertNodeHelper(&((*ptr)->leftPtr),value);
         
         
         if (value>(*ptr)->data)
             insertNodeHelper(&((*ptr)->rightPtr),value);
          else
              cout<<value<<"dup"<<endl;
}
 
 template<class NODETYPE>
 void Tree<NODETYPE>::preOrderTraversal() const
     {preOrderHelper(rootPtr);}
 
 template<class NODETYPE>
 void Tree<NODETYPE>::preOrderHelper(
      TreeNode<NODETYPE>*ptr) const
 {
      if (ptr!=0) {
           preOrderHelper(ptr->leftPtr);
          cout<<ptr->data<<' ';
         
          preOrderHelper(ptr->rightPtr);
      }
}

template<class NODETYPE>
void Tree<NODETYPE>::inOrderTraversal()const
{
     inOrderHelper(rootPtr);}
     

template<class NODETYPE>
void Tree<NODETYPE>::inOrderHelper(
       TreeNode<NODETYPE>*ptr) const
{
       if (ptr!=0){
                   inOrderHelper(ptr->leftPtr);
                   cout<<ptr->data<<' ';
                   inOrderHelper(ptr->rightPtr);
                   }
}
 
 template<class NODETYPE>
 void Tree<NODETYPE>::postOrderTraversal() const
 {postOrderHelper(rootPtr);}
 
 
 template<class NODETYPE>
 void Tree<NODETYPE>::postOrderHelper(
                 TreeNode<NODETYPE> *ptr) const
 {
      if (ptr!=0){
                  postOrderHelper(ptr->leftPtr);
                  postOrderHelper(ptr->rightPtr);
                  }
}
#endif 
     

           
              

 

#include <iostream>
#include <iomanip>
#include "tree.h"
using std::cout;
using std::cin;
using std::setiosflags;
using std::ios;
using std::setprecision;

int main()
{
    Tree<int> intTree;
    int intVal,i;
    cout<<"enter 10 integer values:\n";
    for (i=0;i<10;i++){
        cin>>intVal;
        intTree.insertNode(intVal);
        }
        cout<<"\npreorder traversal\n";
        intTree.preOrderTraversal();
        cout<<"\nInorder traversal\n";
        intTree.inOrderTraversal();
        cout<<"\nPostorder traversal\n";
        intTree.postOrderTraversal();
        
        Tree<double> doubleTree;
        double doubleVal;
        cout<<"\n\n\nenter 10 double values:\n"
            <<setiosflags(ios::fixed|ios::showpoint)
            <<setprecision(1);
        for (i=0;i<10;i++){
            cin>>doubleVal;
            doubleTree.insertNode(doubleVal);
            }
        cout<<"\nPreorder traversal\n";
        doubleTree.preOrderTraversal();
        
        cout<<"\nINorder traversal\n";
        doubleTree.inOrderTraversal();
        
        cout<<"\nPostorder traversal\n";
        doubleTree.postOrderTraversal();
        return 0;
}