下面头文件中包含了递归和非递归的实现，最下面的main.cpp文件有例子
可以把BinNode.h和main.cpp文件放在同一个目录下，然后用c++11标准编译来测试，如用gnu编译器可以：
g++ -std=c++11 main.cpp即可
头文件(实现文件) BinNode.h:
#ifndef _BIN_NODE_
#define _BIN_NODE_
#include
#include
#include
#include
#include
//节点定义 template
struct BinNode{ T data; BinNode* lchild; BinNode* rchild; }; /**************** Recursive Operation (递归操作) **********************/ //从vector容器中读取元素以前序遍历的顺序创建二叉树 template
void CreatePreBinTree(BinNode
*& Tree,const std::vector
& data,const T& null_value){ static auto it=data.begin(); if(it==data.end()) return; //std::cout<<"now data is: "<<*it<
; Tree->data=*it++; CreatePreBinTree(Tree->lchild,data,null_value); CreatePreBinTree(Tree->rchild,data,null_value); } else{ Tree=nullptr; ++it; } } //二叉树的前序序列和中序序列能唯一的确定一颗二叉树，从前序序列和中序序列的容器中读取元素创建唯一一颗二叉树 //形参in_it_begin和in_it_end必须传入in_order容器的begin()和end()迭代器 template
BinNode
* CreateBinTreeFromPreAndInorderList(const std::vector
& pre,const std::vector
& in_order,typename std::vector
::const_iterator in_it_begin,typename std::vector
::const_iterator in_it_end){ static auto pre_it=pre.begin(); if(pre_it==pre.end() || in_it_begin==in_it_end) return nullptr; BinNode
* tree=new BinNode
; tree->data=*pre_it; auto p=std::find(in_it_begin,in_it_end,*pre_it); ++pre_it; if(p==in_it_end) return nullptr; tree->lchild=CreateBinTreeFromPreAndInorderList(pre,in_order,in_it_begin,p); tree->rchild=CreateBinTreeFromPreAndInorderList(pre,in_order,p+1,in_it_end); return tree; } //以前序遍历的方式打印二叉树 template
void PrintPreOrder(BinNode
* Tree){ if(nullptr==Tree) return; std::cout<
data; PrintPreOrder(Tree->lchild); PrintPreOrder(Tree->rchild); } //以中序遍历的方式打印二叉树 template
void PrintInOrder(BinNode
* Tree){ if(nullptr==Tree) return; PrintInOrder(Tree->lchild); std::cout<
data; PrintInOrder(Tree->rchild); } //以后序遍历的方式打印二叉树 template
void PrintPostOrder(BinNode
* Tree){ if(nullptr==Tree) return; PrintPostOrder(Tree->lchild); PrintPostOrder(Tree->rchild); std::cout<
data; } //用后序遍历的方式计算二叉树的高度 template
int Height(BinNode
* Tree){ if(nullptr==Tree) return 0; int i=Height(Tree->lchild); int j=Height(Tree->rchild); return i>j?i+1:j+1; } //用前序遍历的方式判断两颗二叉树是否相等 template
bool Equal(BinNode
* Tree1,BinNode
* Tree2){ if(nullptr==Tree1 && nullptr==Tree2) return true; if(nullptr==Tree1 || nullptr==Tree2) return false; if(Tree1->data!=Tree2->data) return false; if(!Equal(Tree1->lchild,Tree2->lchild)) return false; if(!Equal(Tree1->rchild,Tree2->rchild)) return false; return true; } //用后续遍历的方式销毁一颗二叉树 template
void Destroy(BinNode
*& Tree){ if(nullptr==Tree) return; Destroy(Tree->lchild); Destroy(Tree->rchild); std::cout<<"Destroy node: "<
data<<'\n'; delete Tree; Tree=nullptr; } //以前序遍历的方式打印二叉树，打印结果以广义表形式呈现 template
void PrintGeneralizedList(BinNode
* Tree){ if(Tree==nullptr) return; std::cout<
data; if(nullptr!=Tree->lchild || nullptr!=Tree->rchild){ std::cout<<'('; PrintGeneralizedList(Tree->lchild); std::cout<<','; PrintGeneralizedList(Tree->rchild); std::cout<<')'; } } /***************** Nonrecursive Operation (非递归操作) ************************/ //以前序遍历的广义表为数据，创建前序遍历二叉树 template
void CreateBinTreeFromPreOrderGL(BinNode
*& tree,const std::vector
& data){ auto it=data.begin(); if(it==data.end()) return; std::stack
*> st; BinNode
*p; int flag=1; tree=nullptr; while(it!=data.end()){ switch(*it){ case '(': st.push(p); flag=1; break; case ',': flag=2; break; case ')': st.pop(); break; default: p=new BinNode
; p->data=*it; p->lchild=p->rchild=nullptr; if(nullptr==tree) tree=p; else{ if(1==flag) st.top()->lchild=p; else st.top()->rchild=p; } } ++it; } } //以前序遍历方式打印二叉树的非递归实现 template
void PrintPreOrderNre(BinNode
* tree){ std::stack
*> st; BinNode
*p=tree; do{ if(nullptr==p){ if(!st.empty()){ p=st.top()->rchild; st.pop(); } } else{ std::cout<
data; st.push(p); p=p->lchild; } }while(!st.empty() || nullptr!=p); } //以中序遍历方式打印二叉树的非递归实现 template
void PrintInOrderNre(BinNode
* tree){ std::stack
*> st; BinNode
*p=tree; do{ if(nullptr==p){ if(!st.empty()){ p=st.top()->rchild; if(!st.empty()) std::cout<
data; st.pop(); } } else{ st.push(p); p=p->lchild; } }while(!st.empty() || nullptr!=p); } //以后序遍历方式打印二叉树的非递归实现 template
void PrintPostOrderNre(BinNode
* tree){ std::stack
*> st; BinNode
*p=tree,*q=nullptr; do{ if(nullptr==p){ if(!st.empty()){ p=st.top(); if(nullptr!=p->rchild && p->rchild!=q) p=p->rchild; else{ std::cout<
data; st.pop(); q=p; p=nullptr; } } } else{ st.push(p); p=p->lchild; } }while(!st.empty() || nullptr!=p); } //以层次序遍历方式打印二叉树 template
void PrintLevelOrder(BinNode
* tree){ if(nullptr==tree) return; std::queue
*> qe; BinNode
*curr; qe.push(tree); while(!qe.empty()){ curr=qe.front(); qe.pop(); std::cout<
data; if(nullptr!=curr->lchild) qe.push(curr->lchild); if(nullptr!=curr->rchild) qe.push(curr->rchild); } } //获取指定节点的父节点，如果父节点找不到，则返回nullptr template
BinNode
* GetFatherNode(BinNode
* tree,const T dest){ if(tree==nullptr || dest==tree->data) return nullptr; BinNode
* curr=tree; std::queue
*> qe; qe.push(curr); while(!qe.empty()){ curr=qe.front(); qe.pop(); if(nullptr!=curr->lchild){ if(dest==curr->lchild->data) return curr; else qe.push(curr->lchild); } if(nullptr!=curr->rchild){ if(dest==curr->rchild->data) return curr; else qe.push(curr->rchild); } } return nullptr; } #endif
main文件 main.cpp:
#include "BinNode.h"
int main(){
std::vector
vc={'A','B','C','#','#','D','E','#','G','#','#','F','#','#','#'};
std::vector
vcc={'A','(','B','(','D',',','E','(','G',',',')',')',',','C','(',',','F',')',')'};
std::vector
pre_vc={'A','B','H','F','D','E','C','K','G'};
std::vector
in_order_vc={'H','B','D','F','A','E','K','C','G'};
BinNode
*tree; //CreatePreBinTree(tree,vc,'#'); //CreateBinTreeFromPreOrderGL(tree,vcc); tree=CreateBinTreeFromPreAndInorderList(pre_vc,in_order_vc,in_order_vc.begin(),in_order_vc.end()); std::cout<<"PreOrder traval is:\n"; PrintPreOrder(tree); std::cout<<"\n\nNonrecursive PreOrder traval is:\n"; PrintPreOrderNre(tree); std::cout<<"\n\nInOrder traval is:\n"; PrintInOrder(tree); std::cout<<"\n\nNonrecursive InOrder traval is:\n"; PrintInOrderNre(tree); std::cout<<"\n\nPostOrder traval is:\n"; PrintPostOrder(tree); std::cout<<"\n\nNonrecursive PostOrder traval is:\n"; PrintPostOrderNre(tree); std::cout<<"\n\nLevelOrder traval is:\n"; PrintLevelOrder(tree); std::cout<<"\n\nThe Generalized List is:\n"; PrintGeneralizedList(tree); std::cout<<'\n'; std::cout<<'\n'; const char c='C'; std::cout<<"The father node of '"<
<<"' is: "; BinNode
*f=GetFatherNode(tree,c); if(f!=nullptr) std::cout<
data<
<
300
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
