C++实现一颗二叉树

Binary_Tree.h

#pragma once
#include<iostream>
#include<stack>
#include<queue>
//节点
struct Node
{
 char data;
 struct Node *Lchild,*Rchild;
};
template <class T>
class Binary_Tree
{
private:
 Node *root;
public:
 Binary_Tree(const T *arr);
 Node *Create_Tree(const T *arr);
 ~Binary_Tree();
 void Clear();
 void clear(Node* &cur);
 void Empty();
 void PreOrder();
 void preorder(Node *cur);
 void InOrder();
 void inorder(Node *cur);
 void PostOrder();
 void postorder(Node *cur);
 void PreOrder_Non();
 void InOrder_Non();
 void PostOrder_Non();
 void LevelOrder();
 size_t Find_K_Level(size_t K);
 size_t find_K_level(Node *cur,size_t K);
 T Find(const T e);
 Node *find(Node *cur,const T e);
 size_t Size();
 size_t size(Node *cur);
 size_t Depth();
 size_t depth(Node *cur);
};
//构造函数
template <class T>
Binary_Tree<T>::Binary_Tree(const T *arr)
{
 root = Create_Tree(arr);
}
//创建一颗二叉树
template <class T>
Node *Binary_Tree<T>::Create_Tree(const T *arr)
{
 Node *cur = NULL;
 static int i = 0;
 T ch = arr[i++];
 if (ch == '#')
  cur = NULL;
 else
 {
  cur = new Node;
  if(!cur)
  {
   cout<<"error";
   return NULL;
  }
  cur->data = ch;
  cur->Lchild = Create_Tree(arr);
  cur->Rchild = Create_Tree(arr);
 }
 return cur;
}
//析构函数
template <class T>
Binary_Tree<T>::~Binary_Tree()
{
 Clear();
}
//清空一颗二叉树
template <class T>
void Binary_Tree<T>::Clear()
{
 clear(root);
}
template <class T>
void Binary_Tree<T>::clear(Node* &cur)
{
 if (cur)
 {
  if (cur->Lchild)
   clear(cur->Lchild);
  if (cur->Rchild)
   clear(cur->Rchild);
  delete cur;
  cur = NULL;
 }
}
//判断是否为空树
template <class T>
void Binary_Tree<T>::Empty()
{
 if (root)
  cout<<"false";
 else
  cout<<"ture";
 cout<<endl;
}
//前序遍历（递归）
template <class T>
void Binary_Tree<T>::PreOrder()
{
 preorder(root);
 cout<<endl;
}
template <class T>
void Binary_Tree<T>::preorder(Node *cur)
{
 if (cur == NULL)
  return;
 else
 {
  cout<<cur->data;
  preorder(cur->Lchild);
  preorder(cur->Rchild);
 }
}
//中序遍历（递归）
template <class T>
void Binary_Tree<T>::InOrder()
{
 inorder(root);
 cout<<endl;
}
template <class T>
void Binary_Tree<T>::inorder(Node *cur)
{
 if (cur == NULL)
  return;
 else
 {
  inorder(cur->Lchild);
  cout<<cur->data;
  inorder(cur->Rchild);
 }
}
//后序遍历（递归）
template <class T>
void Binary_Tree<T>::PostOrder()
{
 postorder(root);
 cout<<endl;
}
template <class T>
void Binary_Tree<T>::postorder(Node *cur)
{
 if (cur == NULL)
  return;
 else
 {
  postorder(cur->Lchild);
  postorder(cur->Rchild);
  cout<<cur->data;
 }
}
//前序遍历（非递归）
template <class T>
void Binary_Tree<T>::PreOrder_Non()
{
 Node *cur = root;
 if (cur == NULL)
  return;
 stack<Node *> s;
 while (cur || !s.empty())
 {
  while (cur)
  {
   s.push(cur);
   cout<<cur->data;
   cur = cur->Lchild;
  }
  Node *top = s.top();
  s.pop();
  cur = top->Rchild;
 }
 cout<<endl;
}
//中序遍历（非递归）
template <class T>
void Binary_Tree<T>::InOrder_Non()
{
 Node *cur = root;
 if (cur == NULL)
  return;
 stack<Node *> s;
 while (cur || !s.empty())
 {
  while (cur)
  {
   s.push(cur);
   cur = cur->Lchild;
  }
  Node *top = s.top();
  cout<<top->data;
  s.pop();
  cur = top->Rchild;
 }
 cout<<endl;
}
//后序遍历（非递归）
template <class T>
void Binary_Tree<T>::PostOrder_Non()
{
 Node *prev = NULL;
 Node *cur = root;
 if (cur == NULL)
  return;
 stack<Node *> s;
 while (cur || !s.empty())
 {
  while (cur)
  {
   s.push(cur);
   cur = cur->Lchild;
  }
  Node *top = s.top();
  if (top->Rchild == NULL || top->Rchild == prev)
  {
   cout<<top->data;
   prev = top;
   s.pop();
  }
  else
   cur = top->Rchild;
 }
 cout<<endl;
}
//层序遍历
template <class T>
void Binary_Tree<T>::LevelOrder()
{
 Node *cur = root;
 if (cur == NULL)
  return;
 queue<Node *> q;
 q.push(cur);
 while (!q.empty())
 {
  Node *top = q.front();
  q.pop();
  cout<<top->data;
  if (top->Lchild)
   q.push(top->Lchild);
  if (top->Rchild)
   q.push(top->Rchild);
 }
 cout<<endl;
}
//第K层的节点数
template <class T>
size_t Binary_Tree<T>::Find_K_Level(size_t K)
{
 return find_K_level(root,K);
}
template <class T>
size_t Binary_Tree<T>::find_K_level(Node *cur,size_t K)
{
 if (cur == NULL || K < 1)
  return 0;
 if (K == 1)
  return 1;

 size_t left = find_K_level(cur->Lchild,K-1);
 size_t right = find_K_level(cur->Rchild,K-1);
 return left+right;
}
//查找e是否在里面并返回
template <class T>
T Binary_Tree<T>::Find(const T e)
{
 if (find(root,e) == NULL)
  return '#';
 else
  return find(root,e)->data;
}
template <class T>
Node *Binary_Tree<T>::find(Node *cur,const T e)
{
 if (cur == NULL)
  return cur;
 Node *ret = NULL;
 if (cur->data == e)
  return cur;
 else
 {
  ret = find(cur->Lchild,e);
  if (ret == NULL)
   ret = find(cur->Rchild,e);
 }
 return ret;
}
//查找二叉树的总结点
template <class T>
size_t Binary_Tree<T>::Size()
{
 return size(root);
}
template <class T>
size_t Binary_Tree<T>::size(Node *cur)
{
 size_t ret = 0;
 if (cur == NULL)
  return ret;
 else
 {
  ret++;
  ret += size(cur->Lchild);
  ret += size(cur->Rchild);
 }
 return ret;
}
//返回二叉树的深度
template <class T>
size_t Binary_Tree<T>::Depth()
{
 return depth(root);
}
template <class T>
size_t Binary_Tree<T>::depth(Node *cur)
{
 if (cur == NULL)
  return 0;
 int left = depth(cur->Lchild)+1;
 int right = depth(cur->Rchild)+1;
 return left > right ? left : right;
}