二叉树操作总结

#include<iostream>
#include<stack>
#include<queue>
#include<string>
#include<vector>
using namespace std;

template<class T>
struct Node{
T value;
Node* pLeft;
Node* pRight;
bool isFirst;
Node(T value){
this->value = value;
pLeft = pRight = NULL;
isFirst = true;
}
};

template<class T>
class Tree{
private:
Node<T>* root;
public:
Tree(){
root = NULL;
}

//插入值
/*1.如果当前节点为空，则插入值到当前节点
*2.如果当前节点不为空，且待插入值大于当前节点，则进入当前节点的右子节点
*3.如果当前节点不为空，且待插入值小于当前节点，则进入当前节点的左子节点
* */
void insert(T value){
mInsert(root, value);
}

//递归前中后遍历
void recursive(){
mRecursive(root);
}

//前序遍历(非递归)
/*
* 1.将二叉树的根节点设为p
* 2.访问节点p，如果p不为空，则将p压入栈
* 3.访问p的左子节点，如果不为空，则将p的值设为p的左子节点，将p压入栈，循环此过程
* 4.如果p的左子节点为空，则弹出栈顶元素，判断top节点的右子节点是否为空
* 5.如果top节点的右子节点不为空，则将p的值设为top节点的右子节点,并将p压入栈，执行3过程
* 6.如果top节点的右子节点为空，则继续弹出栈顶元素，循环此过程，直至找到一个右子节点不为空的top节点
* 7.直到栈空为止结束
* */
void DLR(){
stack<Node<T>*> s;
Node<T>* p = root;
while(p || !s.empty()){
while(p){
cout << p->value << ' ';
s.push(p);
p = p->pLeft;
}
if(!s.empty()){
p = s.top();
s.pop();
p = p->pRight;
}
}
}

//中序遍历(非递归)
/*
* 思路和前序遍历非递归过程十分相似
**/
void LDR(){
stack<Node<T>*> s;
Node<T>* p = root;
while(p || !s.empty()){
while(p){
s.push(p);
p = p->pLeft;
}
if(!s.empty()){
p = s.top();
s.pop();
cout << p->value << ' ';
p = p->pRight;
}
}
}

//后序遍历(非递归需要辅助节点isFirst)
/*
*思路：程序保证满足两个条件：
*1.当一个节点有未访问过的子节点时，需要先访问其子节点
*2.不能重复访问一个节点的子节点
*
*1.将根节点压入栈，设根节点为Node
*2.按照顺序将Node节点的右子节点(不为空并且之前没有访问过)和左子节点(不为空并且之前没有访问过)压入栈
*3.判断Node节点是否等于栈顶节点，如果不等于，则让Node节点等于栈顶节点，继续2过程
*4.如果Node节点等于栈顶节点，此时说明已经到了最底层叶子节点，退出循环
*5.判断栈是否为空，不为空的话，让Node节点等于栈顶节点，输出值，并弹出此节点，让Node节点等于下一个栈顶节点，进入2过程，循环此过程
*6.直到栈为空，结束此过程
* */
void LRD_ONE(){
stack<Node<T>*> s;
Node<T>* p = root;
s.push(p);
p->isFirst = false;
while(p || !s.empty()){
while(p){
if(p->pRight && p->pRight->isFirst){
p->pRight->isFirst = false;
s.push(p->pRight);
}
if(p->pLeft && p->pLeft->isFirst){
p->pLeft->isFirst = false;
s.push(p->pLeft);
}
if(s.empty())
break;
p == s.top() ? p = NULL : p = s.top();
}
if(!s.empty()){
p = s.top();
s.pop();
cout << p->value << ' ';
s.empty() ? p = NULL : p = s.top();
}
}
}

//后续遍历(非递归不需要辅助节点isFirst)
/*
*思路：程序保证满足两个条件：
*1.当一个节点有未访问过的子节点时，需要先访问其子节点
*2.不能重复访问一个节点的子节点
**/
void LRD_TWO(){
stack<Node<T>*> s;
s.push(root);
Node<T>* cur = NULL;
Node<T>* pre = NULL;
while(!s.empty()){
cur = s.top();
//下面这行代码可以满足上面两个条件
if((cur->pLeft == NULL && cur->pRight == NULL) || (pre != NULL && (pre == cur->pLeft || pre == cur->pRight))){
cout << cur->value << ' ';
s.pop();
pre = cur;
}else{
if(cur->pRight != NULL)
s.push(cur->pRight);
if(cur->pLeft != NULL)
s.push(cur->pLeft);
}
}
}

//按层打印
void treeShow(){
queue<Node<T>*> in;
Node<T>* last = NULL;
in.push(root);
while(!in.empty()){
while(!in.empty() && in.front() != last){
Node<T>* p = in.front();
in.pop();
cout << p->value << ' ';
if(p->pLeft){
if(!last) last = p->pLeft;
in.push(p->pLeft);
}
if(p->pRight){
if(!last) last = p->pRight;
in.push(p->pRight);
}
}
cout << endl;
last = NULL;
}
}

//按照层遍历模式进行序列化
//思路：广度优先搜索
string seriaByLayer(){
string result;
queue<Node<T>*> in;
Node<T>* last = NULL;
in.push(root);
while(!in.empty()){
while(!in.empty() && (!last || (last && in.front() != last))){
Node<T>* p = in.front();
in.pop();
if(p) {
result += (p->value+'0');
in.push(p->pLeft);
in.push(p->pRight);
if(p->pLeft && !last) last = p->pLeft;
if(p->pRight && !last) last = p->pRight;
}
else result += '#';
result += '!';
}
last = NULL;
}
return result;
}

//按照层遍历模式进行反序列化
//思路：
/*
* 1.把root放入队列
* 2.读字符串的值，
*      每次遇到一个有效的值，就把该值压入队列，
*      遇到一个空值或者有效的值，就将该值赋给队列首节点的左右子树，
*      当队列首节点的左右子树都赋值后，就弹出首节点
*      继续往下读字符串的值
* 3.循环此过程
* */
void deSeriaByLayer(string str){
if(str.length() < 1) return;

Node<T>* root = new Node<T>(str[0] - 48);
queue<Node<T>*> in;
in.push(root);
int index = 0; //0表示应该赋值给左子树，1表示应该赋值给右子树

for(int i = 1; i < int(str.length()); i++){
if(str[i] == '!') continue;
else if(str[i] == '#'){
if(index == 0) index = 1;
else if(index == 1) {
index = 0;
in.pop();
}
}
else{
Node<T>*& p = in.front();
Node<T>* node = new Node<T>(str[i] - 48);
in.push(node);
if(index == 0) {
p->pLeft = node;
index = 1;
}
else if(index == 1){
p->pRight = node;
in.pop();
index = 0;
}
}
}

this->root = root;
}

protected:
void mInsert(Node<T>*& root, T value){
if(!root){
Node<T>* node = new Node<T>(value);
root = node;
}
else if(value > root->value)
mInsert(root->pRight, value);
else if(value < root->value)
mInsert(root->pLeft, value);
}
void mRecursive(Node<T>* root){
if(root){
cout << root->value << ' ';//前序
mRecursive(root->pLeft);
//cout << root->value << ' ';//中序
mRecursive(root->pRight);
//cout << root->value << ' ';//后序
}
}
//将一个只知道根节点的树赋给指定的树
void setRootToTree(Node<T>* root){
this->root = root;
}
};

int main1(){
Tree<int> tree;
for(int i = 0; i < 100; i++){
if(i%2) tree.insert(i);
else tree.insert(-i);
}
tree.treeShow();

return 0;
}