链表队列与二叉树基本操作

/*********************************
 * file : m.cpp
 * 功能: 1,建链表队列
         2,定义二叉树
   3,对二叉树进行中序,后序遍历
   4,对二叉树进行层次遍历
   5,计算二叉树的叶子数目
   6,计算二叉树的深度
   7,实现复制二叉树
   8,删除二叉树
 * 创建日期:2007-9-24
*********************************/

#include <iostream>
using namespace std;

template <typename T>
class qnode
{
public:
 qnode()
 {
  next = 0;
 }
 qnode(const T &v):value(v)
 {
  next = 0;
 }

public:
 T value;
 qnode<T> *next;
};

template <typename T>
class Quen
{
public:
 qnode<T> *front;
 qnode<T> *rear;

public:
 Quen():front(0),rear(0)
 {}
 Quen(const T &v)
 {
  qnode<T> *p = new qnode<T>(v);
  front = p;
  rear = p;
 }

 void push(const T &v)
 {
  qnode<T> *p = new qnode<T>(v);
  rear->next = p;
  rear = p;
 }
 
 void pop()
 {
  if(empty() == false)
  {
   qnode<T> *p = front;
   front = front->next;
   delete p;
  }
  else
   cout << "Queen empty!" << endl;
 }

 bool empty()
 {
  return !((front != 0) && (rear != 0));
 }

 T getfront()
 {
  return front->value;
 }
};

// 以上为链表队列的实现
// 以下为二叉树的遍历操作

template <typename T>
class tnode
{
public:
 tnode():left(0), right(0)
 {}
 tnode(const T &v, tnode<T> *lef =  0, tnode<T> *rig = 0):value(v),left(lef),right(rig)
 {}

public:
 T value;
 tnode<T> *left;
 tnode<T> *right;
};

//中序遍历
template <typename T>
void InOrder(tnode<T> *root)
{
 if( root != 0)
 {
  InOrder(root->left);
  cout << root->value << ' ';
  InOrder(root->right);
 }
}

// 后序遍历
template <typename T>
void PostOrder(tnode<T> *root)
{
 if( root != 0)
 {
  PostOrder(root->left);
  PostOrder(root->right);
  cout << root->value << ' ';
 }
}

// 借助链表队列实现迭代层次遍历
template <typename T>
void level(tnode<T> *root)
{
 Quen<tnode<T> *> *q = new Quen<tnode<T> *>(root);
 tnode<T> *p;

// q->push(root);
 while(q->empty() == false)
 {
  p = q->getfront();
  cout << p->value << ' ';
  if( p->left != 0 )
   q->push(p->left);
  if( p->right != 0 )
   q->push(p->right);
  q->pop();
 }
}

// 计算叶子数目
template <typename T>
void countleaf(tnode<T> *root, int &count)
{
 if( root != 0 )
 {
  if( (root->left == 0) && (root->right == 0))
   count++;

  countleaf(root->left, count);
  countleaf(root->right, count);
 }
}

// 计算树高度
template <typename T>
int depth(tnode<T> *root)
{
 int ldepth, rdepth, ndepth;
 if( root->left == 0 )
  ldepth = -1;
 else
  ldepth = depth(root->left);

 if( root->right == 0 )
  rdepth = -1;
 else
  rdepth = depth(root->right);

 ndepth = 1 + ((ldepth > rdepth) ? ldepth : rdepth);

 return ndepth;
}

// 复制二叉树
template <typename T>
tnode<T> *copytree( tnode<T> *root )
{
 tnode<T> *lp, *rp, *np;
 if( root == 0 )
  return 0;
 lp = copytree( root->left );
 rp = copytree( root->right );
 np = new tnode<T>(root->value, lp, rp);

 return np;
}

// 删除二叉树
template <typename T>
void deltree(tnode<T> *root)
{
 if( root != 0 )
 {
  deltree(root->left);
  deltree(root->right);
  delete root;
 }
}

int main()
{
 tnode<int> *p, *root;
 
 root = new tnode<int>(1);
 root = new tnode<int>(11, 0, root);
 p = new tnode<int>(4);
 root->left = p;
 p = new tnode<int>(2);
 p = new tnode<int>(6, 0, p);
 root = new tnode<int>(5, p, root);

 InOrder(root);
 cout << endl;

 PostOrder(root);
 cout << endl;

 level(root);
 cout << endl;

 int count = 0;
 countleaf(root, count);
 cout << "count = " << count << endl;

 cout << "depth = " << depth(root) << endl;

 level(copytree(root));
 cout << endl;
 
 //deltree(root);
// level(root);
 cout << endl;

 return 0;
} 

 

输出:

6 2 5 4 11 1
2 6 4 1 11 5
5 6 11 2 4 1
count = 3
depth = 2
5 6 11 2 4 1