二叉树的生成与遍历演示，附源代码，在VC7.1下可编译运行通过。

头文件：

#ifndef BINARY_TREE_H
#define BINARY_TREE_H
template<class elemType> struct nodeType
{
 elemType info;
 nodeType* llink;
 nodeType* rlink;
};

template<class elemType> class BinaryTreeType
{
public:
 const BinaryTreeType<elemType>& operator = (const BinaryTreeType<elemType>&);
 bool isEmpty(void);
 void inorderTraversal(void);
 void preorderTraversal(void);
 void postorderTraversal(void);
 int treeHeight(void);
 int treeNodeCount(void);
 int treeLeavesCount(void);
 void destoryTree(void);
 BinaryTreeType(const BinaryTreeType<elemType>& otherTree);
 BinaryTreeType(void);
 ~BinaryTreeType(void);
 void createTree(void);

protected:
 nodeType<elemType>* root;

private:
 void copyTree(nodeType<elemType>* &copiedTreeRoot,nodeType<elemType>* otherTreeRoot);
 void destory(nodeType<elemType>* &p);
 void inorder(nodeType<elemType>* p);
 void preorder(nodeType<elemType>* p);
 void postorder(nodeType<elemType>* p);
 int height(nodeType<elemType>* p);
 int max(int x,int y);
 int nodeCount(nodeType<elemType>* p);
 int leavesCount(nodeType<elemType>* p);
 void create(nodeType<elemType>*&p,int i);
};
#endif

 

实现文件

#include "BinaryTree.h"
#include <iostream>
using namespace std;
template<class elemType> BinaryTreeType<elemType>::BinaryTreeType(void)
{
 root = NULL;
}

template<class elemType> BinaryTreeType<elemType>::~BinaryTreeType(void)
{
 destoryTree();
}

template<class elemType> BinaryTreeType<elemType>::BinaryTreeType(const BinaryTreeType<elemType>& otherTree)
{
 if(otherTree.root == NULL)
 {
  this->root = NULL;
 }
 else
 {
  copyTree(root,otherTree.root);
 }
}

template<class elemType> void BinaryTreeType<elemType>::inorderTraversal(void)
{
 inorder(root);
}

template<class elemType> void BinaryTreeType<elemType>::preorderTraversal(void)
{
 preorder(root);
}

template<class elemType> void BinaryTreeType<elemType>::postorderTraversal(void)
{
 postorder(root);
}

template<class elemType> int BinaryTreeType<elemType>::treeHeight(void)
{
 return height(root);
}

template<class elemType> int BinaryTreeType<elemType>::treeNodeCount(void)
{
 return nodeCount(root);
}

template<class elemType> int BinaryTreeType<elemType>::treeLeavesCount(void)
{
 return leavesCount(root);
}

template<class elemType> void BinaryTreeType<elemType>::inorder(nodeType<elemType>* p)
{
 if(p != NULL)
 {
  inorder(p->llink);
  cout<<p->info<<"  ";
  inorder(p->rlink);
 }
}

template<class elemType> void BinaryTreeType<elemType>::preorder(nodeType<elemType>* p)
{
 if(p!= NULL)
 {
  cout<<p->info<<"  ";
  preorder(p->llink);
  preorder(p->rlink);
 }
}

template<class elemType> void BinaryTreeType<elemType>::postorder(nodeType<elemType>* p)
{
 if(p!= NULL)
 {
  postorder(p->llink);
  postorder(p->rlink);
  cout<<p->info<<"  ";
 }
}

template<class elemType> int BinaryTreeType<elemType>::height(nodeType<elemType>* p)
{
 if(p == NULL)
 {
  return 0;
 }
 else
 {
  return 1 + max(height(p->llink),height(p->rlink));
 }
}

template<class elemType> int BinaryTreeType<elemType>::max(int x,int y)
{
 if( x >= y)
 {
  return x;
 }
 else
 {
  return y;
 }
}

template<class elemType> int BinaryTreeType<elemType>::nodeCount(nodeType<elemType>* p)
{
 if(p == NULL)
 {
  return 0;
 }
 else
 {
  return 1 + nodeCount(p->llink) + nodeCount(p->rlink);
 }
}

template<class elemType> int BinaryTreeType<elemType>::leavesCount(nodeType<elemType>* p)
{
 if(p == NULL) 
 {
  return 0;
 }
 else if(p != NULL && p->llink == NULL && p->rlink == NULL)
 {
  return 1;
 }
 else
 {
  return leavesCount(p->llink) + leavesCount(p->rlink);
 }
}

template<class elemType> void BinaryTreeType<elemType>::copyTree(nodeType<elemType>*& copiedTreeRoot,nodeType<elemType>* otherTreeRoot)
{
 if(otherTreeRoot == NULL)
 {
  copiedTreeRoot = NULL;
 }
 else
 {
  copiedTreeRoot = new nodeType<elemType>;
  copiedTreeRoot->llink = NULL;
  copiedTreeRoot->rlink = NULL;
  copiedTreeRoot->info = otherTreeRoot->info;
  copyTree(copiedTreeRoot->llink,otherTreeRoot->llink);
  copyTree(copiedTreeRoot->rlink,otherTreeRoot->rlink);
 }
}

template<class elemType> void BinaryTreeType<elemType>::destory(nodeType<elemType>*& p)
{
 if(p == NULL)
 {
  return;
 }
 if(p->llink != NULL)
 {
  destory(p->llink);
 }
 else if(p->rlink != NULL)
 {
  destory(p->rlink);
 }
 else
 {
  delete p;
  p = NULL;
 }
}

template<class elemType> void BinaryTreeType<elemType>::destoryTree()
{
 destory(root);
}

template<class elemType> bool BinaryTreeType<elemType>::isEmpty()
{
 if(root == NULL)
 {
  return true;
 }
 else
 {
  return false;
 }
}

template<class elemType> const BinaryTreeType<elemType>& BinaryTreeType<elemType>::operator =(const BinaryTreeType<elemType>& otherTree)
{
 if(this != otherTree)
 {
  if(root != NULL)
  {
   destory(root);
  }
  if(otherTree == NULL)
  {
   root = NULL;
  }
  else
  {
   copyTree(root,otherTree.root);
  }
 }
 return *this;
}

template<class elemType> void BinaryTreeType<elemType>::createTree()
{
 int i = 4;
 create(root,i);
}

template<class elemType> void BinaryTreeType<elemType>::create(nodeType<elemType>* &p,int i)
{
 i--;
 if(i >= 0)
 {
  nodeType<elemType>* q = new nodeType<elemType>;
  q->info = i + 1;
  q->llink = NULL;
  q->rlink = NULL;
  p = q;
  create(p->llink,i);
  create(p->rlink,i);
 }
 else
 {
  return;
 }
}
void main()
{
 BinaryTreeType<int> tree; 
 tree.createTree();
 tree.inorderTraversal();
 cout<<endl;
 tree.postorderTraversal();
 cout<<endl;
 tree.preorderTraversal();
 cout<<endl;
 cout<< tree.treeHeight()<<endl;
 cout<< tree.treeLeavesCount()<<endl;
 cout<< tree.treeNodeCount()<<endl;
}