在上篇二叉树中又增加了递归查找父结点和非递归查找父结点，还有增加二叉搜索树的插入和删除结点的算法

在上篇二叉树中又增加了递归查找父结点和非递归查找父结点，还有增加二叉搜索树的插入和删除结点的算法

#include<iostream>
#include<stack>
#include<queue>
using namespace std;
//------------- 非递归后续遍历的标志位-------------------------
enum Tags
{
 Left, Right                //Left为左标志位,Right为右标志位
};
//--------------提前声明非递归后续遍历的栈类--------------------
template<class T>
class StackElement;
//--------------提前声明二叉树类模板----------------------------
template<class T>                
class BinaryTree;
//--------------二叉树结点类------------------------------------
template<class T>
class BinaryTreeNode
{
 friend class StackElement<T>;
 friend class BinaryTree<T>;                         //声明二叉树类为友元类
 T data;                                          //数据域
 BinaryTreeNode<T> *leftChild;                    //左树指针
 BinaryTreeNode<T> *rightChild;                   //右树指针
};
//--------------非递归后续遍历的栈类-----------------------------
template<class T>
class StackElement
{
public:
 BinaryTreeNode<T>*pointer;
 Tags tag;
};
//--------------二叉树类-----------------------------------------
template<class T>
class BinaryTree
{
 BinaryTreeNode<T>*root;
public:
 BinaryTree();
 BinaryTreeNode<T>*&Root();                          //返回根
 void CreatBinaryTree(BinaryTreeNode<T>*&rt);       //创建二叉树
 void PreOrder(BinaryTreeNode<T>*rt);               //递归前序遍历
 void InOrder(BinaryTreeNode<T>*rt);                //递归中序遍历
 void PostOrder(BinaryTreeNode<T>*rt);              //递归后序遍历
 void PreOrderWithoutRecusion();                    //非递归的前序遍历
 void InOrderWithoutRecusion();                     //非递归的中序遍历
 void PostOrderWithoutRecusion();                   //非递归的后续遍历
 void LevelOrder();                                 //层序遍历
 BinaryTreeNode<T>* Parent(BinaryTreeNode<T>*rt, T Value);           //前序递归查找父结点
 BinaryTreeNode<T>* ParentWithoutRecusion(T Value);                  //前序非递归查找父结点
 void insert(BinaryTreeNode<T>*&rt, T Value);       //二叉搜索树的插入结点“二叉搜索树英文全称Binary search tree简称BST”
 void remove(BinaryTreeNode<T>*&rt, T Value);       //二叉搜索树的删除结点
 BinaryTreeNode<T>* deletemin(BinaryTreeNode<T>*&rt);       //返回右子树值最小结点的地址，并且删除该结点;
 void OptionMenu()                                  //功能选项
 {
  cout << "请选择功能" << endl;
  cout << "1:递归前序遍历" << endl;
  cout << "2:递归中序遍历" << endl;
  cout << "3:递归后续遍历" << endl;
  cout << "4:非递归前续遍历" << endl;
  cout << "5:非递归中续遍历" << endl;
  cout << "6:非递归后续遍历" << endl;
  cout << "7:层序遍历" << endl;
  cout << "8:前序递归查找父结点" << endl;
  cout<< "9:前序非递归查找父结点" << endl;
  int n;
  cin >> n;
  T Value;                        //用于8,9功能用户输入的变量
  BinaryTreeNode<T>*Pointer;      //用于8,9功能用户输入的变量
  switch (n)
  {
  case 1:
   cout << "递归前序遍历:";
   PreOrder(root);
   
   break;
  case 2:
   cout << "递归中序遍历:";
   InOrder(root);
   break;
  case 3:
   cout << "递归后序遍历:";
   PostOrder(root);
   break;
  case 4:
   cout << "非递归前序遍历:";
   PreOrderWithoutRecusion();
   break;
  case 5:
   cout << "非递归中续遍历:";
   InOrderWithoutRecusion();
   break;
  case 6:
   cout << "非递归后续遍历:";
   PostOrderWithoutRecusion();
   break;
  case 7:
   cout << "层序遍历:" << endl;
   LevelOrder();
   cout << endl;
   break;
  case 8:
   cout << "请输入待查找的结点" << endl;
   cin >> Value;
   Pointer = Parent(root, Value);
   if (Pointer != NULL)
   {
    cout << Value << "的父节点为:" <<Pointer->data << endl;
   }
   else
   {
    cout << "没有找到" << Value << "的父结点" << endl;
   }
   break;
  case 9:
   cout << "请输入待查找的结点" << endl;
   cin >> Value;
   Pointer = ParentWithoutRecusion(Value);
   if (Pointer != NULL)
   {
    cout << Value << "的父节点为:" << Pointer->data << endl;
   }
   else
   {
    cout << "没有找到" << Value << "的父结点" << endl;
   }
   break;
  }
  
 }
};
template<class T>
BinaryTree<T>::BinaryTree()
{
 cout << "请输入根节点:" << endl;
 cout << "输入#代表结点指针指向空" << endl;
 CreatBinaryTree(root);
 if (root != NULL)
  cout << "root=" << root->data << endl;
 else
  cout << "The BinaryTree is empty." << endl;
}
template<class T>
BinaryTreeNode<T>*&BinaryTree<T>::Root()
{
 return root;
}
template<class T>
void BinaryTree<T>::CreatBinaryTree(BinaryTreeNode<T>*&rt)
{
 T ch;
 cin >> ch;
 if (ch == '#')
 {
  rt = NULL;
 }
 else
 {
  rt = new BinaryTreeNode<T>;
  rt->data = ch;
  cout << "调用左孩子" << endl;
  CreatBinaryTree(rt->leftChild);
  cout << "调用右孩子" << endl;
  CreatBinaryTree(rt->rightChild);
 }
}
template<class T>
void BinaryTree<T>::PreOrder(BinaryTreeNode<T>*rt)
{
 if (rt != NULL)
 {
  cout << rt->data << " ";
  PreOrder(rt->leftChild);
  PreOrder(rt->rightChild);
 }
  
 
}
template<class T>
void BinaryTree<T>::InOrder(BinaryTreeNode<T>*rt)
{
 if (rt != NULL)
 {
  InOrder(rt->leftChild);
  cout << rt->data << " ";
  InOrder(rt->rightChild);
 }
}
template<class T>
void BinaryTree<T>::PostOrder(BinaryTreeNode<T>*rt)
{
 if (rt != NULL)
 {
  PostOrder(rt->leftChild);
  PostOrder(rt->rightChild);
  cout << rt->data << " ";
 }
}
template<class T>
void BinaryTree<T>::PreOrderWithoutRecusion()
{
 stack<BinaryTreeNode<T>*>aStack;
 BinaryTreeNode<T>*pointer = root;
 aStack.push(NULL);
 while (pointer)
 {
  cout << pointer->data << " ";
  if (pointer->rightChild != NULL)
   aStack.push(pointer->rightChild);
  if (pointer->leftChild != NULL)
   pointer = pointer->leftChild;
  else
  {
   pointer = aStack.top();
   aStack.pop();
  }
 }
}
template<class T>
void BinaryTree<T>::InOrderWithoutRecusion()
{
 stack<BinaryTreeNode<T>*>aStack;
 BinaryTreeNode<T>*Pointer = root;
 while (!aStack.empty()||Pointer)
 {
  if (Pointer)
  {
   aStack.push(Pointer);
   Pointer = Pointer->leftChild;
  }
  else
  {
   Pointer = aStack.top();
   aStack.pop();
   cout << Pointer->data << " ";
   Pointer = Pointer->rightChild;
  }
 }
}
template<class T>
void BinaryTree<T>::PostOrderWithoutRecusion()
{
 StackElement<T> element;
 stack<StackElement<T>>aStack;
 BinaryTreeNode<T>*pointer;
 pointer = root;
 while (!aStack.empty()||pointer)
 {
  while (pointer != NULL)
  {
   element.pointer = pointer;
   element.tag = Left;
   aStack.push(element);
   pointer = pointer->leftChild;
  }
  element = aStack.top();
  aStack.pop();
  pointer = element.pointer;
  if (element.tag == Left)
  {
   element.tag = Right;
   aStack.push(element);
   pointer = pointer->rightChild;
  }
  else
  {
   cout << pointer->data << " ";
   pointer = NULL;
  }
 }
}
template<class T>
void BinaryTree<T>::LevelOrder()
{
 queue<BinaryTreeNode<T>*>aQueue;
 BinaryTreeNode<T>*pointer = root;
 aQueue.push(pointer);
 while (!aQueue.empty())
 {
  pointer = aQueue.front();
  aQueue.pop();
  cout << pointer->data << " ";
  if (pointer->leftChild != NULL)
  {
   aQueue.push(pointer->leftChild);
  }
  if (pointer->rightChild != NULL)
  {
   aQueue.push(pointer->rightChild);
  }
 }
}
template<class T>
BinaryTreeNode<T>* BinaryTree<T>::Parent(BinaryTreeNode<T>*rt, T Value)
{
 BinaryTreeNode<T>*tmp;
 if (rt == NULL)
  return NULL;
 if (rt->leftChild != NULL&&Value == rt->leftChild->data)
 {
  return rt;
 }
 if (rt->rightChild != NULL&&Value == rt->rightChild->data)
 {
  return rt;
 }
 if ((tmp = Parent(rt->leftChild, Value)) != NULL)
 {
  return tmp;
 }
 if ((tmp = Parent(rt->rightChild, Value)) != NULL)
 {
  return tmp;
 }
 return NULL;
}
template<class T>
BinaryTreeNode<T>* BinaryTree<T>::ParentWithoutRecusion(T Value)
{
 BinaryTreeNode<T>* Pointer = root;
 stack<BinaryTreeNode<T>*> aStack;
 aStack.push(NULL);
 while (Pointer)
 {
  if (Pointer->leftChild != NULL && Pointer->leftChild->data == Value)
   return Pointer;
  if (Pointer->rightChild != NULL && Pointer->rightChild->data == Value)
  {
   return Pointer;
  }
  if (Pointer->rightChild != NULL)
  {
   aStack.push(Pointer->rightChild);
  }
  if (Pointer->leftChild != NULL)
  {
   Pointer = Pointer->leftChild;
  }
  else
  {
   Pointer = aStack.top();
   aStack.pop();
  }
 }
}
template<class T>
void BinaryTree<T>::insert(BinaryTreeNode<T>*&rt, T Value)
{
 if (rt == NULL)
 {
  rt = new BinaryTreeNode<T>;
  rt->data = Value;
 }
 else if (Value < rt->data)
  insert(rt->leftChild, Value);
 else if (Value > rt->data)
  insert(rt->rightChild, Value);
}
template<class T>
void BinaryTree<T>::remove(BinaryTreeNode<T>*&rt, T Value)
{
 if (rt == NULL)
  cout << Value << " is not in the tree" << endl;
 else if (Value < rt->data)
  remove(rt->leftChild, Value);
 else if (Value > rt->data)
  remove(rt->rightChild, Value);
 else
 {
  BinaryTreeNode<T>*temp = rt;
  if (rt->leftChild == NULL)
   rt = rt->rightChild;
  else if (rt->rightChild == NULL)
   rt = rt->leftChild;
  else
  {
   temp = deletemin(rt->rightChild);
   rt->data = temp->data;
  }
 }
 
}
template<class T>
BinaryTreeNode<T>* BinaryTree<T>::deletemin(BinaryTreeNode<T>*&rt)
{
 if (rt->leftChild != NULL)
  return deletemin(rt->leftChild);
 else
 {
  BinaryTreeNode<T>*temp = rt;
  rt = rt->rightChild;
  return temp;
 }
}
int main()
{
 BinaryTree<char>a;
 a.OptionMenu();
 a.remove(a.Root(), 'G');
 
 a.LevelOrder();
}