二叉树的那些事

二叉树的操作，最近写了这些代码，同时也借鉴了网上前辈的们的经验。有时间再继续完善。创建的问二叉排序树。




#include<iostream>

#include<stack>

#include<vector>

#include<queue>

#include<Windows.h>

using namespacestd;

template<class Type>

class BStree;

int maxlen=0;

intdistancebetweenNode=0;

二叉树节点的定义

template<classType>

class BinaryNode

{

friend class BStree<Type>;

public:

BinaryNode():left(NULL),right(NULL){}

BinaryNode(const Type&value):data(value),left(NULL),right(NULL){}

private:

Type data;

BinaryNode *left;

BinaryNode *right;

int maxleft;

int maxright;

//bool isFirst;

};

template<classType>

class BStree

{

private:

BinaryNode<Type> *root;

bool isFirst;

public:

//int maxlen;

BStree():root(NULL){}

BStree(const Type & tree);

BinaryNode<Type>*GetRoot()const{return root;}

Type createBitree(const Type & value);

//==================================================//

//树的递归遍历

//=================================================//

void preOrder(const BinaryNode<Type>*startNode);

void inOrder(const BinaryNode<Type>*starNode);

void PostOrder(constBinaryNode<Type>*startNode);



//=================================================//

//树的非递归遍历

//===============================================//

void noRecursivePre(BinaryNode<Type>* startNode);

void noRecursiveIn(BinaryNode<Type>*startNode);

voidnoRecursivePost1(BinaryNode<Type>* startNode);

voidnoRecursivePost2(BinaryNode<Type>* startNode);

//二叉树中节点的最大距离

void FindMaxLen(BinaryNode<Type>*startNode);

//二叉树最低公共节点

bool findpath(BinaryNode<Type>*startNode,vector<int> &path,int key);

int findLCA(BinaryNode<Type>*startNode,int key1,int key2);

//二叉树任意两个节点之间的距离

voidFindLen(BinaryNode<Type>*startNode,int key1,int key2);

//二叉树的深度

inttreeDepth(BinaryNode<Type>*startNode);

int treeDepthNoRe(BinaryNode<Type>*startNode);

//二叉树的宽度

inttreeWidth(BinaryNode<Type>*startNode);

//判断平衡二叉树

boolbalanceTree(BinaryNode<Type>*startNode);



};



创建二叉树

template<classType>

TypeBStree<Type>::createBitree(const Type &value)

{

if(root==NULL)

{

root=new BinaryNode<Type>(value);

}

else

{

BinaryNode<Type> *node=root;

while(1)

{

if(value>node->data)

{

if(node->right==NULL)

{

node->right=newBinaryNode<Type>(value);

break;

}

else

{

node=node->right;

}

}

else

{

if(node->left==NULL)

{

node->left=newBinaryNode<Type>(value);

break;

}

else

{

node=node->left;

}

}

}

}

return value;

}

二叉树线序遍历（递归）

template<classType>

voidBStree<Type>::preOrder(const BinaryNode<Type> *startNode)

{

if(startNode==NULL)

return ;

else

{

cout<<startNode->data<<"";

preOrder(startNode->left);

preOrder(startNode->right);



}



}

二叉树中序遍历（递归）

template<classType>

voidBStree<Type>::inOrder(const BinaryNode<Type>*startNode)

{

if(startNode==NULL)

return;

else

{

inOrder(startNode->left);

cout<<startNode->data<<"";

inOrder(startNode->right);

}

}

二叉树后序遍历（递归）

template<classType>

voidBStree<Type>::PostOrder(const BinaryNode<Type>*startNode)

{

if(startNode==NULL)

return;

else

{

PostOrder(startNode->left);

PostOrder(startNode->right);

cout<<startNode->data<<"";

}

}

二叉树先序遍历（非递归）

template<classType>

voidBStree<Type>::noRecursivePre( BinaryNode<Type>*startNode)

{

stack<BinaryNode<Type> *>s;

BinaryNode<Type> *p=startNode;

while(p!=NULL||!s.empty())

{

while(p!=NULL)

{

cout<<p->data<<"";

s.push(p);

p=p->left;

}

if(!s.empty())

{

p=s.top();

s.pop();

p=p->right;

}

}



}

template<classType>

二叉树中序遍历（非递归）

voidBStree<Type>::noRecursiveIn(BinaryNode<Type>* startNode)

{

stack<BinaryNode<Type> *>s;

BinaryNode<Type>*p=startNode;

while(p!=NULL||!s.empty())

{

while(p!=NULL)

{

s.push(p);

p=p->left;

}

if(!s.empty())

{

p=s.top();

s.pop();

cout<<p->data<<"";

p=p->right;



}

}



}

二叉树后序遍历（非递归）

template<classType>

voidBStree<Type>::noRecursivePost1(BinaryNode<Type>* startNode)

{

stack<BStree<Type> *>s;

BinaryNode<Type> *p=startNode;

BStree<Type>*temp;

while(p!=NULL||!s.empty())

{

while(p!=NULL)

{

BStree<Type>*btn=(BStree *)malloc(sizeof(BStree));

btn->root=p;

btn->isFirst=true;

s.push(btn);

p=p->left;

}

if(!s.empty())

{

temp=s.top();

s.pop();

if(temp->isFirst==true)//表示第一次访问

{

temp->isFirst=false;

s.push(temp);

p=temp->root->right;

}

else

{

cout<<temp->root->data<<"";

p=NULL;

}

}

}





}

二叉树后序遍历2（非递归）

template<classType>

voidBStree<Type>::noRecursivePost2(BinaryNode<Type>* startNode)

{

stack<BinaryNode<Type> *>s;

BinaryNode<Type> *cur;//当前节点

BinaryNode<Type> *pre=NULL;//前一次被访问的节点

s.push(startNode);

while(!s.empty())

{

cur=s.top();

if((cur->left==NULL&&cur->right==NULL)||(pre!=NULL&&(pre==cur->left||pre==cur->right)))

{

cout<<cur->data<<"";

s.pop();

pre=cur;

}

else

{

if(cur->right!=NULL)

s.push(cur->right);

if(cur->left!=NULL)

s.push(cur->left);

}

}

}

二叉树而节点之间的最大距离

template<class Type>

voidBStree<Type>::FindMaxLen(BinaryNode<Type>* startNode)

{

int tmp;

if(startNode==NULL)return;

if(startNode->left==NULL)startNode->maxleft=0;

if(startNode->right==NULL)startNode->maxright=0;

if(startNode->left!=NULL)

FindMaxLen(startNode->left);

if(startNode->right!=NULL)

FindMaxLen(startNode->right);

if(startNode->left!=NULL)

{

tmp=(startNode->left->maxleft>startNode->left->maxright)?(startNode->left->maxleft):(startNode->left->maxright);

startNode->maxleft=tmp+1;

}

if(startNode->right!=NULL)

{

tmp=(startNode->right->maxleft>startNode->right->maxright)?(startNode->right->maxleft):(startNode->right->maxright);

startNode->maxright=tmp+1;

}



maxlen=(startNode->maxleft+startNode->maxright)>(maxlen)?(startNode->maxleft+startNode->maxright):maxlen;



}

获得遍历序列

template<classType>

boolBStree<Type>::findpath(BinaryNode<Type> *startNode,vector<int>&path, int key)

{

if(startNode==NULL)return false;

path.push_back(startNode->data);

if(startNode->data==key) return true;

boolfind=(findpath(startNode->left,path,key)||findpath(startNode->right,path,key));

if(find) return true;

path.pop_back();

return false;

}

获得二叉树两个节点之间的最低公共节点

template<classType>

intBStree<Type>::findLCA(BinaryNode<Type>*startNode,int key1,int key2)

{

vector<int> path1,path2;

bool find1=findpath(startNode,path1,key1);

bool find2=findpath(startNode,path2,key2);

if(find1&&find2)

{

int ans;

for(int i=0;i<path1.size();i++)

{

if(path1[i]!=path2[i])

break;

else

ans=path1[i];

}

return ans;

}

return -1;

}

template<classType>

voidBStree<Type>::FindLen(BinaryNode<Type>*startNode,int key1,int key2)

{

vector<int> path1,path2;

int len=0;

bool find1=findpath(startNode,path1,key1);

bool find2=findpath(startNode,path2,key2);

if(find1&&find2)

{

if(path1.size()>=path2.size())

{

len=path1.size()-path2.size();

for(int i=path1.size()-len-1,j=path2.size()-1;j>=0&&i>=0;i--,j--)

{

if(path1[i]!=path2[j])

distancebetweenNode=distancebetweenNode+1;//74 10 1 5 -1 2 9 13 12 11 14 s

else

break;

}

}

else

{

len=path2.size()-path1.size();

for(inti=path2.size()-len-1,j=path1.size()-1;j>=0&&i>=0;j--,i--)

{

if(path1[j]!=path2[i])

distancebetweenNode++;

else

break;

}

}



distancebetweenNode=2*distancebetweenNode+len;



}

}

二叉树的深度

template<classType>

intBStree<Type>::treeDepth(BinaryNode<Type>*startNode)

{

if(startNode==NULL)

return 0;

returntreeDepth(startNode->left)>treeDepth(startNode->right)?(treeDepth(startNode->left)+1):(treeDepth(startNode->right)+1);

}

二叉树深度非递归

template<classType>

intBStree<Type>::treeDepthNoRe(BinaryNode<Type>*startNode)

{



}

二叉树宽度

template<classType>

intBStree<Type>::treeWidth(BinaryNode<Type>*startNode)

{

if(startNode==NULL)

return 0;

int nLastLevelWidth=0;

int nTempLastLevelWidth;

int nCurLevelWidth;

int nWidth=1;

queue<BinaryNode<Type>*>myqueue;

myqueue.push(startNode);//将根节点入队

nLastLevelWidth=1;

BinaryNode<Type>*pCur=NULL;

while(!myqueue.empty())

{

nTempLastLevelWidth=nLastLevelWidth;

while(nTempLastLevelWidth!=0)

{

pCur=myqueue.front();//取出队列头元素

myqueue.pop();

if(pCur->left!=NULL)

{

myqueue.push(pCur->left);

}

if(pCur->right!=NULL)

{

myqueue.push(pCur->right);

}

nTempLastLevelWidth--;

}

nCurLevelWidth=myqueue.size();

nWidth=nCurLevelWidth>nWidth?nCurLevelWidth:nWidth;

nLastLevelWidth=nCurLevelWidth;



}

return nWidth;

}

判断平衡二叉树

template<classType>

boolBStree<Type>::balanceTree(BinaryNode<Type>*startNode)

{

int diff,left,right;



if(startNode==NULL)

return true;

left=treeDepth(startNode->left);

right=treeDepth(startNode->right);

diff=left-right;

if(diff>1||diff<-1)

return false;

else

returnbalanceTree(startNode->left)&&balanceTree(startNode->right);



}



int main()

{



BStree<int> tree;

int num;

while(cin>>num)

tree.createBitree(num);

cout<<"输出递归先序遍历的序列"<<endl;

tree.preOrder(tree.GetRoot());

cout<<endl;

cout<<"输出递归中序遍历的序列"<<endl;

tree.inOrder(tree.GetRoot());

cout<<endl;

cout<<"输出递归后序遍历的序列"<<endl;

tree.PostOrder(tree.GetRoot());

cout<<endl;

cout<<"输出非递归先序遍历的序列"<<endl;

tree.noRecursivePre(tree.GetRoot());

cout<<endl;

cout<<"输出非递归中序遍历的序列"<<endl;

tree.noRecursiveIn(tree.GetRoot());

cout<<endl;

cout<<"输出非递归后序遍历的序列"<<endl;

tree.noRecursivePost1(tree.GetRoot());

cout<<endl;

cout<<"输出非递归后序遍历的序列2"<<endl;

tree.noRecursivePost2(tree.GetRoot());

cout<<endl;

cout<<"输出二叉树节点之间的最大距离:"<<endl;

tree.FindMaxLen(tree.GetRoot());

cout<<maxlen<<endl;

cout<<"输出二叉树两个节点之间的最低公共节点"<<endl;

cout<<tree.findLCA(tree.GetRoot(),5,9)<<endl;

cout<<"输出二叉树任意两个节点之间的距离"<<endl;

tree.FindLen(tree.GetRoot(),11,14);

cout<<distancebetweenNode<<endl;

cout<<"输出二叉树的深度"<<endl;

cout<<tree.treeDepth(tree.GetRoot())<<endl;

cout<<"输出二叉树的宽度"<<endl;

cout<<tree.treeWidth(tree.GetRoot())<<endl;

cout<<"判断是否为平衡二叉树"<<endl;

cout<<tree.balanceTree(tree.GetRoot())<<endl;



system("pause");

return 0;

}