二叉树三种遍历方式，有先序，中序或者后序，中序恢复二叉树等操作

//头文件
//BinaryTreeNode.h
#ifndef BINARYTREENODE_H
#define BINARYTREENODE_H
template<typename T>
class BinaryTreeNode{
public:
T data;
BinaryTreeNode<T>* leftChild;
BinaryTreeNode<T>* rightChild;
BinaryTreeNode(){

}
BinaryTreeNode(const T& val, BinaryTreeNode<T>* str, BinaryTreeNode<T>* ptr) :data(val), leftChild(str), rightChild(ptr){

}
};
#endif
//BinaryTree.h
#ifndef BINARYTREE_H
#define BINARYTREE_H
#include"BinaryTreeNode.h"
#include<iostream>
#include<queue>
#include<stack>
#include<cstring>
using namespace std;
template<typename T>
class BinaryTree{
private:
BinaryTreeNode<T>* root;
public:
BinaryTree();
~BinaryTree();
//一下为二叉树的基本操作
void creat();
bool isEmpty();
BinaryTreeNode<T>* getRoot();
T reValue(BinaryTreeNode<T>* str)const;
void reSet(BinaryTreeNode<T>* str, const T& val);
void Deep()const;
//输出操作
void PrintInOrder(BinaryTreeNode<T>* str);
void PrintLevelOrder();
void PrintPostOrder(BinaryTreeNode<T>* str);
//该函数是模拟先序，中序和后序，中序恢复出二叉树的操作
void simulate();
private:
//有中序序列和先序序列确定二叉树,递归形式的算法
void DefineBinaryTree(BinaryTreeNode<T>* &str,char* preOrder,char* midOrder,int length);
void DefineBinaryTree(char* preOrder, char* midOrder);
//有后序序列，中序序列确定二叉树
void DefineBinaryTreePost(BinaryTreeNode<T>* &str,char* postOrder,char* midOrder,int length);
void DefineBinaryTreePost(char* postOrder, char* midOrder);
//清空树
void makeEmpty(BinaryTreeNode<T>* &str);
private:
int deep(BinaryTreeNode<T>* str)const;
void CreatBiTree(BinaryTreeNode<T>* &str);
//非递归方法求树的深度
int deepPrivate()const;
private:
//该函数是用非递归方法，在给出先序和后序数列时，求出二叉树,该函数是为void DefineBinaryTree(char* preOrder, char* midOrder);
//函数服务的
int posChar(char ch, char* str);
};
template<typename T>
int BinaryTree<T>::posChar(char ch, char* str)
{
if (strlen(str) == 0)
{
cout << "the char* is empty" << endl;
exit(true);
}
int i = 0;
while (str[i] != '\0')
{
if (ch == str[i])
{
return i;
}
i++;
}
return -1;
}
template<typename T>
void BinaryTree<T>::DefineBinaryTree(char* preOrder, char* midOrder)
{
if (strlen(preOrder) == 0 || strlen(midOrder) == 0)
{
this->root = NULL;
return;
}
//记录每个与先序中节点对应的后序中的节点的位置
int pos;
//position,node两个栈存放的是pos,和生成的每个节点
stack<int>position;
stack<BinaryTreeNode<T>*>node;
//str,ptr用于生成节点
BinaryTreeNode<T>* str = NULL;
BinaryTreeNode<T>* ptr = NULL;
str = new BinaryTreeNode<T>(preOrder[0], NULL, NULL);
this->root = str;
pos = posChar(preOrder[0], midOrder);
position.push(pos);
node.push(str);
int i = 1;
while (preOrder[i] != '\0')
{
pos = posChar(preOrder[i], midOrder);
if (pos == -1)
{
cout << "the match is error" << endl;
exit(true);
}
str = new BinaryTreeNode<T>(preOrder[i], NULL, NULL);
if (pos < position.top())
{
//当num < position.top()时，则该节点是左节点
ptr = node.top();
ptr->leftChild = str;
node.push(str);
position.push(pos);
}
else
{
while (!position.empty() && pos > position.top())
{
ptr = node.top();
position.pop();
node.pop();
}
ptr->rightChild = str;
node.push(str);
position.push(pos);
}
i++;
}
}
template<typename T>
void BinaryTree<T>::simulate()
{
/*char preOrder[100];*/
char postOrder[100];
char midOrder[100];
cout << "input the postOrder: ";
/*cin >> preOrder;*/
cin >> postOrder;
//在这里对后序序列进行处理，将整个字符数组的顺序颠倒过来
char str[100];
int j = 0;
int count = strlen(postOrder);
for (int i = 0; i < count; j++, i++)
{
str[j] = postOrder[i];
}
str[j] = '\0';
int i = 0;
for (j = strlen(str) - 1; i < count, j >= 0; j--, i++)
{
postOrder[i] = str[j];
}
postOrder[i] = '\0';
cout << "input the midOrder: ";
cin >> midOrder;
int length = strlen(midOrder);
/*this->DefineBinaryTree(this->root,preOrder,midOrder,length);*/
/*this->DefineBinaryTree(preOrder, midOrder);*/
/*this->DefineBinaryTreePost(this->root, postOrder, midOrder,length);*/
this->DefineBinaryTreePost(postOrder, midOrder);
}
template<typename T>
void BinaryTree<T>::DefineBinaryTree(BinaryTreeNode<T>* &str, char* preOrder, char* midOrder, int length)
{
if (length == 0)
{
str = NULL;
return;
}
str = new BinaryTreeNode<T>(*preOrder, NULL, NULL);
char* pStr = strchr(midOrder, str->data);
if (pStr == NULL)
{
cout << "the midOrder string is wrong" << endl;
exit(true);
}
int leftTreeLength = strlen(midOrder) - strlen(pStr);
int rightTreeLength = length - leftTreeLength - 1;
DefineBinaryTree(str->leftChild, preOrder + 1, midOrder, leftTreeLength);
DefineBinaryTree(str->rightChild, preOrder + leftTreeLength + 1, pStr + 1, rightTreeLength);
}
template<typename T>
void BinaryTree<T>::DefineBinaryTreePost(BinaryTreeNode<T>* &str, char* postOrder, char* midOrder, int length)
{
if (length==0)
{
str = NULL;
return;
}
str = new BinaryTreeNode<T>(*postOrder, NULL, NULL);
char* pStr = strchr(midOrder, str->data);
if (pStr == NULL)
{
cout << "the midOrder is wrong" << endl;
exit(true);
}
//这里的字符串处理有错误
int leftLength = strlen(midOrder) - strlen(pStr);
int rightLength = length - leftLength - 1;
DefineBinaryTreePost(str->leftChild, postOrder + rightLength + 1, midOrder, leftLength);
DefineBinaryTreePost(str->rightChild, postOrder + 1, midOrder + leftLength + 1, rightLength);
}
template<typename T>
void BinaryTree<T>::DefineBinaryTreePost(char* postOrder, char* midOrder)
{
//在该函数中的postOrder序列是顺序已经被颠倒之后的序列
if (strlen(postOrder) == 0 || strlen(midOrder) == 0)
{
this->root = NULL;
return;
}
int pos;
stack<int>position;
stack<BinaryTreeNode<T>*>node;
BinaryTreeNode<T>* str = NULL;
BinaryTreeNode<T>* ptr = NULL;
str = new BinaryTreeNode<T>(postOrder[0], NULL, NULL);
this->root = str;
pos = posChar(str->data, midOrder);
node.push(str);
position.push(pos);
int i = 1;
while (postOrder[i] != '\0')
{
pos = posChar(postOrder[i], midOrder);
if (pos == -1)
{
cout << "the midOrder is error" << endl;
exit(true);
}
str = new BinaryTreeNode<T>(postOrder[i], NULL, NULL);
if (pos < position.top())
{
ptr = node.top();
ptr->leftChild = str;
node.push(str);
position.push(pos);
}
else
{
while (!position.empty() && pos>position.top())
{
ptr = node.top();
node.pop();
position.pop();
}
ptr->rightChild = str;
node.push(str);
position.push(pos);
}
i++;
}
}
template<typename T>
int BinaryTree<T>::deepPrivate()const
{
if (this->root == NULL)
return 0;
BinaryTreeNode<T>* p = this->root;
queue<BinaryTreeNode<T>*>que;
que.push(p);
int deepth = 0;
while (!que.empty())
{
deepth++;
//每次在循环开始之前，都要获得cur=0,和curQueSize的值
//curQueSize记录了每一层中的节点数目，当所有的这一层的节点的左右孩子全部都进入
//队列后退出循环
int cur = 0;
int curQueSize = que.size();
while (cur < curQueSize)
{
cur++;
//每次都要保证在队列中的节点为同一层的节点
p = que.front();
que.pop();
if (p->leftChild)
que.push(p->leftChild);
if (p->rightChild)
que.push(p->rightChild);
}
}
return deepth;
}
template<typename T>
void BinaryTree<T>::Deep()const
{
cout << "the deep is " << this->deepPrivate() << " of the tree" << endl;
}
template<typename T>
int BinaryTree<T>::deep(BinaryTreeNode<T>* str)const
{
if (str == NULL)
return 0;
int h1, h2;
h1 = deep(str->leftChild);
h2 = deep(str->rightChild);
return h1 > h2 ? h1 + 1 : h2 + 1;
}
template<typename T>
bool BinaryTree<T>::isEmpty()
{
if (this->root == NULL)
return true;
return false;
}
template<typename T>
BinaryTree<T>::BinaryTree()
{
this->root = NULL;
}
template<typename T>
BinaryTree<T>::~BinaryTree()
{
this->makeEmpty(this->root);
}
template<typename T>
BinaryTreeNode<T>* BinaryTree<T>::getRoot()
{
if (this->isEmpty())
{
cout << "the tree is empty" << endl;
exit(true);
}
return this->root;
}
template<typename T>
T BinaryTree<T>::reValue(BinaryTreeNode<T>* str)const
{
if (str == NULL)
{
cout << "the point is null" << endl;
exit(true);
}
return str->data;
}
template<typename T>
void BinaryTree<T>::reSet(BinaryTreeNode<T>* str, const T& val)
{
if (str == NULL)
{
cout << "the point is null" << endl;
exit(true);
}
str->data = val;
}
template<typename T>
void BinaryTree<T>::makeEmpty(BinaryTreeNode<T>* &str)
{
if (str)
{
makeEmpty(str->leftChild);
makeEmpty(str->rightChild);
delete str;
}
str = NULL;
}
template<typename T>
void BinaryTree<T>::creat()
{
this->CreatBiTree(root);
}
template<typename T>
void BinaryTree<T>::CreatBiTree(BinaryTreeNode<T>* &str)
{
T value;
if (root == NULL)
{
cout << "the root data is: ";
}
cin >> value;
if (value == '#')
{
str = NULL;
return;
}
else
{
str = new BinaryTreeNode<T>(value, NULL, NULL);
cout << "input the " << str->data << " leftchild: ";
CreatBiTree(str->leftChild);
cout << "input the " << str->data << " rightchild: ";
CreatBiTree(str->rightChild);
}
}
template<typename T>
void BinaryTree<T>::PrintInOrder(BinaryTreeNode<T>* str)
{
if (str != NULL)
{
PrintInOrder(str->leftChild);
cout << str->data << " ";
PrintInOrder(str->rightChild);
}
else
return;
}
template<typename T>
void BinaryTree<T>::PrintLevelOrder()
{
BinaryTreeNode<T>* p = this->root;
queue<BinaryTreeNode<T>*>nodeQue;
if (p != NULL)
nodeQue.push(p);
while (!nodeQue.empty())
{
p = nodeQue.front();
nodeQue.pop();
cout << p->data << " ";
if (p->leftChild)
nodeQue.push(p->leftChild);
if (p->rightChild)
nodeQue.push(p->rightChild);
}
cout << endl;
}
template<typename T>
void BinaryTree<T>::PrintPostOrder(BinaryTreeNode<T>* str)
{
if (str != NULL)
{
PrintPostOrder(str->leftChild);
PrintPostOrder(str->rightChild);
cout << str->data << " ";
}
}
#endif
//主函数
#include"BinaryTree.h"
int main(int argc, char argv[])
{
BinaryTree<char>tree;
tree.creat();
tree.PrintInOrder(tree.getRoot());
cout << endl;
tree.PrintLevelOrder();
tree.PrintPostOrder(tree.getRoot());
cout << endl;
tree.Deep();
tree.simulate();
tree.PrintPostOrder(tree.getRoot());
cout << endl;
tree.Deep();
return 0;
}