数据结构学习系类列八－二叉树的一些操作（c++）

 二叉树的主要操作有：

（1）创建一个二叉树（插入值）

（2）递归法进行前序、中序、后序遍历

（3）非递归法进行前序、中序、后序遍历（利用栈）

（4）二叉树中节点的最大距离

（5）二叉树的深度

（6）在二叉树中进行信息的查找

（7）二叉树节点的数目

（8）二叉树中子节点的数目

（9）判断两个二叉树是否等价

（10）判断整数序列是不是二元查找树的后序遍历结果

（11）二叉树的镜像

（12）输入二叉树，从上向下按层打印，同一层从左到右

（13）将二叉树转化为一个双向链表

 

1 二叉树节点的数据结构与二叉树类的建立

 

/* 二叉树的一些操作 from dinghu721521 mybog:http://blog.csdn.net/dinghu721521 */ #include<iostream> #include<stack> #include<deque> using namespace std; class BSTreeNode { public: int data; BSTreeNode*m_left,*m_right; }; class BSTree { private: BSTreeNode*m_root; public: BSTree():m_root(NULL){} virtual~BSTree(){}; BSTreeNode*GetRoot(){return m_root;} void insert(BSTreeNode* &pNode,int value); //向二叉树中插入数据 void preOrder(BSTreeNode*pCurrent); //递归前序遍历 void inOrder(BSTreeNode*pCurrent); //递归中序遍历 void postOrder(BSTreeNode*pCurrent); //递归后序遍历 void preOrderStack(BSTreeNode*pCurrent); //堆栈前序遍历 void inOrderStack(BSTreeNode*pCurrent); //堆栈中序遍历 void postOrderStack(BSTreeNode*pCurrent); //堆栈后序遍历 int traversal_maxlen(BSTreeNode*pRoot); //二叉树中节点的最大距离 int TreeDepth(BSTreeNode*pRoot); //二叉树的深度 bool find(BSTreeNode*pCurrent,int data); //查找信息 int numOfNode(BSTreeNode*pCurrent); // 二叉树中节点的个数 int leavesNum(BSTreeNode*pCurrent); //求叶子节点的数目 bool is_Equal(BSTreeNode*pNode1,BSTreeNode*pNode2);//判断两棵树是否等价 bool verifySquenceOfBST(int squence[],int length); //判断整数序列是不是二元查找树的后序遍历结果 void Revertsetree(BSTreeNode*pRoot); //二叉树的镜像 void printTree(BSTreeNode*pRoot); //输入二叉树，从上向下按层打印，同一层从左到右 void convertToDoubleList(BSTreeNode*pRoot);//将二叉树转化为一个双向链表 };

2 二叉树的创建

void BSTree::insert(BSTreeNode* &pNode,int value) { if(pNode==NULL) { BSTreeNode*pBSTree=new BSTreeNode(); pBSTree->data=value; pBSTree->m_left=NULL; pBSTree->m_right=NULL; pNode=pBSTree; if(m_root==NULL) m_root=pBSTree;//根节点 } else { if(pNode->data>value) { insert(pNode->m_left,value); } else if(pNode->data<value) { insert(pNode->m_right,value); } else { //相等什么都不做 } } }

3 二叉树的前序遍历、中序遍历、后序遍历（递归）

void BSTree::preOrder(BSTreeNode*pCurrent)//前序遍历 { if(pCurrent!=NULL) { cout<<pCurrent->data<<endl; //pCurrent->data; preOrder(pCurrent->m_left); preOrder(pCurrent->m_right); } }  

 void BSTree::inOrder(BSTreeNode*pCurrent)//中序遍历 { if(pCurrent!=NULL) { inOrder(pCurrent->m_left); //pCurrent->data; cout<<pCurrent->data<<endl; inOrder(pCurrent->m_right); } }

void BSTree::postOrder(BSTreeNode*pCurrent) { if(pCurrent!=NULL) { postOrder(pCurrent->m_left); postOrder(pCurrent->m_right); cout<<pCurrent->data<<endl; } }

4 二叉树的前序遍历、中序遍历、后序遍历（非递归）

void BSTree::preOrderStack(BSTreeNode*pCurrent) { stack<BSTreeNode*> s; BSTreeNode*pNode=new BSTreeNode(); pNode=pCurrent; while(pNode!=NULL||s.size()!=0) { if(pNode) { cout<<pNode->data<<endl; s.push(pNode); pNode=pNode->m_left; } else { pNode=s.top(); s.pop(); pNode=pNode->m_right; } } }

void BSTree::inOrderStack(BSTreeNode*pCurrent) { stack<BSTreeNode*> s; BSTreeNode*pNode=new BSTreeNode; pNode=pCurrent; while(pNode!=NULL||s.size()!=0) { if(pNode) { s.push(pNode); pNode=pNode->m_left; } else { pNode=s.top(); s.pop(); cout<<pNode->data<<endl; pNode=pNode->m_right; } } }

 void BSTree::postOrderStack(BSTreeNode *pCurrent) { stack<BSTreeNode*> s; BSTreeNode*pNode=new BSTreeNode; BSTreeNode*pre=NULL; pNode=pCurrent; s.push(pNode); while(s.size()!=0) { pNode=s.top(); s.pop(); if(pre==pNode->m_left||pre==pNode->m_right) { cout<<pNode->data<<endl; pre=pNode; }else if(pNode->m_left||pNode->m_right) { s.push(pNode); if(pNode->m_right) s.push(pNode->m_right); if(pNode->m_left) s.push(pNode->m_left); }else { cout<<pNode->data<<endl; pre=pNode; } } }

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

int BSTree::traversal_maxlen(BSTreeNode*pRoot) { int maxLength; int maxLen; int maxRgt; if(pRoot==NULL) return 0; if(pRoot->m_left==NULL&&pRoot->m_right==NULL) { return 0; }else if(pRoot->m_left==NULL) { return 1+traversal_maxlen(pRoot->m_right); }else if(pRoot->m_right==NULL) { return 1+traversal_maxlen(pRoot->m_left); }else { maxLen=traversal_maxlen(pRoot->m_left)+1; maxRgt=traversal_maxlen(pRoot->m_right)+1; maxLength=maxLen>maxRgt?maxLen+1:maxRgt+1; return maxLength; } }

6 二叉树的深度

int BSTree::TreeDepth(BSTreeNode*pRoot) { int lenLft=0; int lenRgt=0; if(pRoot==NULL) { return 0; } else { lenLft=TreeDepth(pRoot->m_left); lenRgt=TreeDepth(pRoot->m_right); return (lenLft>lenRgt?lenLft:lenRgt)+1; } }

7 查找某信息是否在二叉树中

bool BSTree::find(BSTreeNode*pCurrent,int data) { if(pCurrent!=NULL) { if(pCurrent->data==data) return true; else if(pCurrent->data>data) { find(pCurrent->m_left,data); } else { find(pCurrent->m_right,data); } } else { return false; } }

8 二叉树中节点的个数

int BSTree::numOfNode(BSTreeNode*pCurrent) { if(pCurrent==NULL) return 0; else return numOfNode(pCurrent->m_left)+numOfNode(pCurrent->m_right)+1; }

9 叶子节点的个数

int BSTree::leavesNum(BSTreeNode*pCurrent) { if(pCurrent) { if(pCurrent->m_left==NULL&&pCurrent->m_right==NULL) return 1; else return leavesNum(pCurrent->m_left)+leavesNum(pCurrent->m_right); } return 0; }

10 判断两个二叉树是否等价

bool BSTree::is_Equal(BSTreeNode*pNode1,BSTreeNode*pNode2) { bool bTree=false; if(pNode1==NULL&&pNode2==NULL) { bTree=true; } else { if(NULL!=pNode1&&NULL!=pNode2) { if(pNode1->data==pNode2->data) { if(is_Equal(pNode1->m_left,pNode2->m_left)) { bTree=is_Equal(pNode1->m_right,pNode2->m_right); } } } } return bTree; }

11 判断整数序列是不是二元查找树的后序遍历结果

bool BSTree::verifySquenceOfBST(int squence[],int length) { if(squence==NULL||length<=0) return false; int root=squence[length-1]; int i=0; for(;i<length-1;++i) //各个值与根节点的关系 { if(squence[i]>root) break; } int j=i; for(;j<length-1;++j) { if(squence[j]<root) return false; } bool left=true; if(i>0) left=verifySquenceOfBST(squence,i);//递归验证子树 bool right=true; if(i<length-1) right=verifySquenceOfBST(squence,j); return (left&&right); }

12 二叉树的镜像

void BSTree::Revertsetree(BSTreeNode*pRoot) { if(!pRoot) return; BSTreeNode*pTemp; pTemp=pRoot->m_left; //左右子树交换 pRoot->m_left=pRoot->m_right; pRoot->m_right=pTemp; if(pRoot->m_left) Revertsetree(pRoot->m_left); if(pRoot->m_right) Revertsetree(pRoot->m_right); }

13 输入二叉树，从上向下按层打印，同一层从左到右

void BSTree::printTree(BSTreeNode*pRoot) { if(pRoot==NULL) return; deque<BSTreeNode*> d; d.push_back(pRoot); while(d.size()!=0) { BSTreeNode*pTemp=d.front(); cout<<pTemp->data<<endl; d.pop_front(); if(pTemp->m_left!=NULL) d.push_back(pTemp->m_left); if(pTemp->m_right!=NULL) d.push_back(pTemp->m_right); } }

14 将二叉树转化为一个双向链表

void BSTree::convertToDoubleList(BSTreeNode*pRoot) { BSTreeNode*pListIndex=NULL; BSTreeNode*pHead=NULL; if(NULL==pRoot) return; if(NULL!=pRoot->m_left) { convertToDoubleList(pRoot->m_left); } /**********************节点接到链表尾**********************/ pRoot->m_left=pListIndex; if(NULL!=pListIndex) { pListIndex->m_right=pRoot; } else { pHead=pRoot; } pListIndex=pRoot; cout<<pRoot->data<<endl; /**********************************************************/ if(NULL!=pRoot->m_right) { convertToDoubleList(pRoot->m_right); } }

所有函数的测试程序

int main() { BSTree*p=new BSTree(); BSTreeNode*pnode=NULL; p->insert(pnode,10); p->insert(pnode,6); p->insert(pnode,4); p->insert(pnode,8); p->insert(pnode,14); p->insert(pnode,12); p->insert(pnode,15); cout<<"********前序遍历*******"<<endl; p->preOrder(p->GetRoot()); cout<<"********中序遍历********"<<endl; p->inOrder(p->GetRoot()); cout<<"********后序遍历********"<<endl; p->postOrder(p->GetRoot()); cout<<"*******栈前序遍历*******"<<endl; p->preOrderStack(p->GetRoot()); cout<<"*******栈中序遍历******"<<endl; p->inOrderStack(p->GetRoot()); cout<<"*******栈后序遍历*******"<<endl; p->postOrderStack(p->GetRoot()); cout<<"*******两节点最大距离*****"<<endl; cout<<p->traversal_maxlen(p->GetRoot())<<endl; cout<<"*******二叉树的深度******"<<endl; cout<<p->TreeDepth(p->GetRoot())<<endl; cout<<"*查找二叉树中是否含有某个数*"<<endl; cout<<p->find(p->GetRoot(),12)<<endl;//查找12,“1”表示二叉树中含有此数，“0”表示没有此数 cout<<"*****二叉树节点的数目*****"<<endl; cout<<p->numOfNode(p->GetRoot())<<endl; cout<<"*****二叉树叶子节点的数目****"<<endl; cout<<p->leavesNum(p->GetRoot())<<endl; cout<<"**判断两个二叉树是否相同***"<<endl; cout<<p->is_Equal(p->GetRoot(),p->GetRoot())<<endl; cout<<"*判断一个序列是否为后续遍历二叉树*"<<endl; //int a[]={5,7,6,9,11,10,8}; //是二叉树 int a[]={7,4,6,5};//不是二叉树 cout<<p->verifySquenceOfBST(a,sizeof(a)/sizeof(int))<<endl; cout<<"******二叉树镜像后按层次打印*****"<<endl; p->Revertsetree(pnode); p->printTree(pnode); cout<<"****按层次打印二叉树****"<<endl; p->Revertsetree(pnode);//恢复原来的二叉树 p->printTree(p->GetRoot()); cout<<"****将二叉树转化为双向链表*****"<<endl; p->convertToDoubleList(p->GetRoot()); return 0; }