[BinaryTree] 二叉树类的实现

二叉树结点的抽象数据类型：

 template<class T>
 class BinaryTreeNode
 {
     friend class BinaryTree<T>;
 private:
     T element;                      //结点的数据域
     BinaryTreeNode<T>* LeftChild;   //结点的左孩子结点
     BinaryTreeNode<T>* RightChild;  //结点的右孩子结点
 public:
     BinaryTreeNode();
     BinaryTreeNode(const T& ele);
     BinaryTreeNode(const T& ele, BinaryTreeNode<T>* l, BinaryTreeNode<T>* r);
     bool isLeaf() const;            //判断该结点是否是叶子结点，若是，则返回true
 };

二叉树结点函数功能实现：

 template<class T>
 BinaryTreeNode<T>::BinaryTreeNode()
 {
     LeftChild = RightChild = NULL;
 }
 template<class T>
 BinaryTreeNode<T>::BinaryTreeNode(const T& ele)
 {
     element = ele;
     LeftChild = RightChild = NULL;
 }
 template<class T>
 BinaryTreeNode<T>::BinaryTreeNode(const T& ele, BinaryTreeNode<T>* l, BinaryTreeNode<T>* r)
 {
     element = ele;
     LeftChild = l;
     RightChild = r;
 }
 template<class T>
 bool BinaryTreeNode<T>::isLeaf() const
 {
     if (LeftChild == NULL && RightChild == NULL)
         return true;
     else return false;
 }

二叉树的抽象数据类型：

 template<class T>
 class BinaryTree
 {
 private:
     BinaryTreeNode<T>* root;
 public:
     BinaryTree();
     ~BinaryTree() {}
     bool IsEmpty() const;                           //判断二叉树是否为空树
     BinaryTreeNode<T>* getRoot() const;             //返回二叉树的根结点
     void breadthFirstOrder(BinaryTreeNode<T>* root);//广度优先遍历以root为根结点的子树
     void preOrder(BinaryTreeNode<T>* root);         //先序遍历以root为根结点的子树
     void inOrder(BinaryTreeNode<T>* root);          //中序遍历以root为根结点的子树
     void postOrder(BinaryTreeNode<T>* root);        //后序遍历以root为根结点的子树
     void deleteBinaryTree(BinaryTreeNode<T>* root); //删除以root为根结点的子树
     void visit(BinaryTreeNode<T>* pointer);         //访问当前结点
     BinaryTreeNode<T>* build_from_pre_and_in(char* preorder, char* inorder, int n);
     //根据前序和中序遍历表达式构造二叉树
     BinaryTreeNode<T>* build_from_post_and_in(char* postorder, char* inorder, int m);
     //根据后序和中序遍历表达式构造二叉树
     int getRootId1(char *preorder, char *inorder, int n);   //返回根结点在中序遍历表达式中序号
     int getRootId2(char *postorder, char *inorder, int m);  //返回根结点在中序遍历表达式中序号
 };

广度优先遍历(队列)：

【思路】根结点入队，队列不空循环，访问队头并出队，左子树不空则入队，右子树不空则入队。

 template<class T>
 void BinaryTree<T>::breadthFirstOrder(BinaryTreeNode<T>* root)
 {
     queue<BinaryTreeNode<T> *> nodeQueue;
     BinaryTreeNode<T> * pointer = root;
     if (pointer)
         nodeQueue.push(pointer);
     while (!nodeQueue.empty())
     {
         pointer = nodeQueue.front();
         visit(pointer);
         nodeQueue.pop();
         if (pointer->LeftChild)
             nodeQueue.push(pointer->LeftChild);
         if (pointer->RightChild)
             nodeQueue.push(pointer->RightChild);
     }
 }

先序遍历：

【思路】

1.访问当前结点

2.当前结点的右儿子结点非空，则入栈

3.左儿子结点非空，使之作为当前结点，否则弹出栈顶元素，使之作为当前结点

4.反复执行1、2、3，至栈空为止

 template<class T>
 void BinaryTree<T>::preOrder(BinaryTreeNode<T>* root)
 {
     stack<BinaryTreeNode<T> *> nodeStack;
     BinaryTreeNode<T> * pointer = root;
     while (!nodeStack.empty() || pointer)
     {
         if (pointer)
         {
             visit(pointer);
             if (pointer->RightChild != NULL)
                 nodeStack.push(pointer->RightChild);
             pointer = pointer->LeftChild;
         }
         else
         {
             pointer = nodeStack.top();
             nodeStack.pop();
         }
     }
 }

中序遍历：

【思路】

1.每遇到一个结点就把它压栈，然后去遍历其左子树

2.遍历完左子树后，从栈顶弹出这个结点并访问之

3.然后遍历该结点的右子树

 template<class T>
 void BinaryTree<T>::inOrder(BinaryTreeNode<T>* root)
 {
     stack<BinaryTreeNode<T> *> nodeStack;
     BinaryTreeNode<T> * pointer = root;
     while (!nodeStack.empty() || pointer)
     {
         if (pointer)
         {
             nodeStack.push(pointer);
             pointer = pointer->LeftChild;
         }
         else
         {
             pointer = nodeStack.top();
             visit(pointer);
             pointer = pointer->RightChild;
             nodeStack.pop();
         }
     }
 }

后序遍历：

【基本思想】

1.每遇到一个结点，先把它推入栈中，去遍历它的左子树

2.遍历完它的左子树后，应继续遍历该结点的右子树

3.遍历完右子树之后，才从栈顶弹出该结点并访问它

【解决方案】

0.将根结点作为当前结点

1.进栈过程：

a.如果当前结点不空且具有左子树，将当前结点压入栈中，否则进入2

b.将当前结点的左子树的根结点设置为当前结点

c.重复 a

2.出栈过程：

a.如果当前结点不空且没有右子树，或者其右子树的根结点已经访问，访问之，否则进入3

b.若栈空，结束，否则取出当前栈顶结点作为当前结点

c.重复 a

3.将当前结点压入栈中

4.将当前结点的右子树的根结点设为当前结点，重复 1

 template<class T>
 void BinaryTree<T>::postOrder(BinaryTreeNode<T>* root)
 {
     stack<BinaryTreeNode<T> * > nodeStack;
     BinaryTreeNode<T> *pre = root, *pointer = root;
     while (pointer)
     {
         //入栈过程
         for (; pointer->LeftChild != NULL; pointer = pointer->LeftChild)
         {
             nodeStack.push(pointer);
         }
         //出栈过程
         while (pointer != NULL && (pointer->RightChild == NULL || pointer->RightChild == pre))
         //当前结点右孩子为空或右孩子刚被访问过，则访问该结点
         {
             visit(pointer);
             pre = pointer;
             if (nodeStack.empty())
                 return;
             pointer = nodeStack.top();
             nodeStack.pop();
         }
         //将当前结点压入栈中
         nodeStack.push(pointer);
         //将当前结点的右子树的根结点设为当前结点
         pointer = pointer->RightChild;
     }
 }

删除以root为根结点的子树：

 template<class T>
 void BinaryTree<T>::deleteBinaryTree(BinaryTreeNode<T>* root)
 {
     if (root->LeftChild != NULL)
         deleteBinaryTree(root->LeftChild);
     if (root->RightChild != NULL)
         deleteBinaryTree(root->RightChild);
     delete root;
     root = NULL;
 }

根据前序和中序遍历表达式构造二叉树：

【思路】根据前序序列，找到根结点在中序序列中的位置，递归根结点的左子树序列和右子树序列。

 template<class T>
 BinaryTreeNode<T>* BinaryTree<T>::build_from_pre_and_in(char* preorder, char* inorder, int n)
 {
     if (n == )
         return NULL;
     char root_element = preorder[];
     int i = ;
     for( ;i < n;i ++)
     {
         if(root_element == inorder[i])
             break;
     }
     BinaryTreeNode<T>* root = new BinaryTreeNode<T>;
     root->element = root_element;
     root->LeftChild = build_from_pre_and_in(preorder + , inorder, i);
     root->RightChild = build_from_pre_and_in(preorder + i + , inorder + i + , n - i - );
     return root;
 }

根据后序和中序遍历表达式构造二叉树：

【思路】根据后序序列，找到根结点在中序序列中的位置，递归根结点的左子树序列和右子树序列。

 template<class T>
 BinaryTreeNode<T>* BinaryTree<T>::build_from_post_and_in(char* postorder, char* inorder, int m)
 {
     if (m == )
         return NULL;
     char root_element = postorder[m - ];
     int i = ;
     for( ;i < m;i ++)
     {
         if(root_element == inorder[i])
             break;
     }
     BinaryTreeNode<T>* root = new BinaryTreeNode<T>;
     root->element = root_element;
     root->LeftChild = build_from_post_and_in(postorder, inorder, i);
     root->RightChild = build_from_post_and_in(postorder+i, inorder + i+, m-i-);
     return root;
 }

测试函数：

 int main()
 {
     BinaryTreeNode<char> *zero = ;
     BinaryTreeNode<char> f('F'), g('G'), h('H');
     BinaryTreeNode<char> d('D', &f, &g), e('E', zero, &h);
     BinaryTreeNode<char> b('B', zero, &d), c('C', zero, &e);
     BinaryTreeNode<char> a('A', &b, &c);
     BinaryTree<char> Tree;
     cout << "广度优先遍历为:" << endl;
     Tree.breadthFirstOrder(&a);
     cout << endl << "先序遍历为:" << endl;
     Tree.preOrder(&a);
     cout << endl << "中序遍历为:" << endl;
     Tree.inOrder(&a);
     cout << endl << "后序遍历为:" << endl;
     Tree.postOrder(&a);
     char *preorder = "ABDFGCEH";
     char *inorder = "BFDGACEH";
     char *postorder = "FGDBHECA";
     int n = strlen(preorder);
     int m = strlen(postorder);
     BinaryTreeNode<char>* root1 = Tree.build_from_pre_and_in(preorder, inorder, n);
     cout << endl << "先序中序构造后广度优先遍历为:" << endl;
     Tree.breadthFirstOrder(root1);
     BinaryTreeNode<char>* root2 = Tree.build_from_post_and_in(postorder, inorder, m);
     cout << endl << "后序中序构造后广度优先遍历为:" << endl;
     Tree.breadthFirstOrder(root2);
     return ;
 }
 //    测试的二叉树
 //           A
 //    B             C
 //       D              E
 //     F   G               H

测试结果：