# 递归创建二叉树，前序，中序，后序遍历二叉树，广义表创建二叉树，非递归前序，中序，后序遍历二叉树

630人阅读 评论(0)

#ifndef TERRMSGLIST_H
#define TERRMSGLIST_H

#include<string>
using std::string;
#include<iostream>
using std::cout;
using std::endl;

class CErrMsgList
{     struct ErrMsgRecord
{  int iNumber;
// vector<string> msg;
char msg[30];
};
ErrMsgRecord MsgList[100];
public:
int iLen;
CErrMsgList( int icase)
{ // int i = 0;
switch( icase )
{ case 0:
{ MsgList[0].iNumber = 0;/*0*/
strcpy(MsgList[0].msg,"Unknown error") ;
// i++;
break;
}
case 1:
{
MsgList[1].iNumber = 1;
strcpy(MsgList[1].msg ,"pramete is illegal");/*1*/
// i++;
break;
}
case 2:
{       MsgList[2].iNumber = 2;
strcpy(MsgList[2].msg , "Out Of Range");/*2*/
// i++;
break;
}
case 3:
{
MsgList[3].iNumber = 3;
strcpy(MsgList[3].msg,"Memory space low");/*3*/
//i++;
break;
}
case 4:
{
MsgList[4].iNumber = 4;
// i++;
break;
}
default:
break;
}//switch

iLen = 4;
}

char * GetMessage(int num )
{  if(num < iLen || num > 100)return NULL;
cout<<MsgList[num].msg<<endl;
return MsgList[num].msg;
}

};
#endif

#ifndef CBTREE_H
#define CBTREE_H
#include<iostream>
using std::cin;
using std::cout;
using std::endl;

#include<new>
#include<iomanip>
using std::setw;
using std::left;
#include <assert.h>

#include "CErrMsgList.h"
//#include "CTreeObject.h"
template<class T>
struct BTreeNode
{ T data;
BTreeNode* left;
BTreeNode * right;
BTreeNode( const T &d):data( d ),left( NULL ),right( NULL )
{};
};

template<class T>
//class BTree : public CTreeObject<T>
class BTree

{ //protected:
public:
BTreeNode<T>* root;

public:
BTree();
virtual ~BTree();
//virtual ObjectNode<T>* GetParent_( ObjectNode<T>* pNode ) = 0;
//virtual ObjectNode<T>* GetLevel( ObjectNode<T>* pNode ) = 0;
virtual void Insert( BTreeNode<T>* pNode,T &element );
virtual BTreeNode<T>* GetLeftChild( BTreeNode<T>* pNode )const ;
virtual BTreeNode<T>* GetRightChild( BTreeNode<T>* pNode )const ;
BTreeNode<T>* GetRoot()const;
virtual /*BTreeNode<T>**/void SetLeftChild( BTreeNode<T>* pNode,T &element ) ;
virtual /*BTreeNode<T>**/void SetRightChild( BTreeNode<T>* pNode,T &element );
//递归创建二叉树
virtual void CreateBTree_recursion( BTreeNode<T>**ptr, const T &element );

virtual void Create( const T &element );
virtual void PutOut( BTreeNode<T>* pNode )const;
virtual void PreOrder( BTreeNode<T>* pNode )const;
virtual void InOrder( BTreeNode<T>* pNode )const;
virtual void ClusterPoster( BTreeNode<T>* pNode )const;
//BTreeNode<T>* LevelOrder( BTreeNode<T>* pNode );
virtual void Visiter()const;
virtual void Release( BTreeNode<T>*  pNode );
};

template<class T>
BTree<T>::BTree()
{
root = NULL;

}

template<class T>
BTree<T>::~BTree()
{ Release( GetRoot() );
}

template<class T>
void BTree<T>::Create( const T &element )
{   CreateBTree_recursion( &root,element);
}

template<class T>
void BTree<T>::Insert( BTreeNode<T>* pNode,T &element )

}

template<class T>
void BTree<T>::CreateBTree_recursion( BTreeNode<T>**ptr ,const T &element )
{
if(*ptr == NULL )
{
(*ptr) = new BTreeNode<T> (element);
assert( *ptr!= NULL );
}
else if(element < (*ptr)->data)
CreateBTree_recursion(&(*ptr)->left, element);
else if(element > (*ptr)->data)
CreateBTree_recursion(&(*ptr)->right, element);
else
cout<<element<<" dup"<<endl;

}

template<class T>
BTreeNode<T>* BTree<T>::GetRoot()const
{ return root;
}
template<class T>
/*BTreeNode<T>**/void BTree<T>::SetLeftChild( BTreeNode<T>* pNode ,T &element)
{ BTreeNode<T>* p = new (BTreeNode<T>)( element);

//if( p == NULL )throw CErrMsgList( 3 );

// p->left = NULL;
//p->right = NULL;
// p->data = element;
pNode->left = p;
// node++;
// return p;
}

template<class T>
/*BTreeNode<T>**/void BTree<T>::SetRightChild( BTreeNode<T>* pNode,T &element )
{ BTreeNode<T>* p = new (BTreeNode<T>)(element);

//if( p == NULL )throw CErrMsgList( 3 );

// p->left = NULL;
// p->right = NULL;
// p->data = element;
pNode->left = p;
// node++;
// return p;
}

template<class T>
BTreeNode<T>* BTree<T>::GetLeftChild( BTreeNode<T>* pNode )const
{// if( pNode->left != NULL )
//return pNode->left;
return pNode->left != NULL ? pNode->left : NULL;
}

template<class T>
BTreeNode<T> * BTree<T>::GetRightChild( BTreeNode<T>* pNode )const
{ return pNode->right != NULL ? pNode->right : NULL;
}

template<class T>
void BTree<T>::InOrder( BTreeNode<T>* pNode )const
{ if( pNode != NULL )
{
InOrder( GetLeftChild( pNode ) );
PutOut( pNode );
InOrder( GetRightChild( pNode ) );
}
}

template<class T>
void BTree<T>::PreOrder( BTreeNode<T>* pNode )const
{ if( pNode != NULL )
{ PutOut( pNode );
// PreOrder( GetLeftChild( pNode ) );
// PreOrder( GetRightChild( pNode ) );
PreOrder( pNode->left );
PreOrder( pNode->right );
}
}

template<class T>
void BTree<T>::ClusterPoster( BTreeNode<T>* pNode )const
{ if( pNode != NULL )
{  ClusterPoster( GetLeftChild( pNode ) );
ClusterPoster( GetRightChild( pNode ) );
PutOut( pNode );
}
}

template<class T>
void BTree<T>::Release( BTreeNode<T>* pNode )
{  if( pNode != NULL )
{  Release( pNode->left );
Release( pNode->right );
delete pNode;
}
}

/*
template<class T>
BTreeNode<T>* BTree<T>::LevelOrder( BTreeNode<T>* pNode )
{
}
*/
template<class T>
void BTree<T>::PutOut( BTreeNode<T>* pNode )const
{  if( pNode != NULL )
cout<<" "<<left<<( pNode->data )<<setw( 2 );
}

template<class T>
void BTree<T>::Visiter()const
{ int selected;
cout<<"please input 1 to putout in preorder,2 to putout in inorder,"
<<"3 to putout in clusterorder,4 to putout in levelorder"
<<"0 to exit/n";
cin>>selected;
do{
switch( selected )
{ case 1:
PreOrder( GetRoot() );
cout<<endl;
cin>>selected;
break;
case 2:
InOrder( GetRoot() );
cout<<endl;
cin>>selected;
break;
case 3:
ClusterPoster( GetRoot() );
cout<<endl;
cin>>selected;
break;
case 4:
// LevelOrder( root );
break;
default :
break;
}
}while(selected != 0);
}

#endif

#ifndef BTREE2_H
#define BTREE2_H
#include<iostream>
using std::cin;
using std::cout;
using std::endl;

#include<new>
#include<iomanip>
using std::setw;
using std::left;
#include <assert.h>
#include <cmath>
#include <stdlib.h>

#include "CBTree.h"
#include "CErrMsgList.h"

template<class T>
class BTree2 : public BTree<T>
{ protected:
// BTreeNode<T>* root;
public:
BTree2();
virtual ~BTree2();
virtual void Create2( const char *, const int  );//广义表创建二叉树
BTreeNode<T>* GListToTree( const char *pArray, const int length );
virtual void PreOrder( BTreeNode<T>* pNode )const;
virtual void InOrder( BTreeNode<T>* pNode )const;
virtual void ClusterPoster( BTreeNode<T>* pNode )const;
virtual void Release( BTreeNode<T>*  pNode );
virtual int GetHeight( BTreeNode<T>* pNode )const;

virtual void Visiter()const;
};

template<class T>
BTree2<T>::BTree2()//:root( NULL )
{ //root = NULL;
}

template<class T>
BTree2<T>::~BTree2()
{  Release( root );
}

template<class T>
void BTree2<T>::Release( BTreeNode<T>* pNode )
{  if( pNode != NULL )
{  Release( pNode->left );
Release( pNode->right );
delete pNode;
}
}

template<class T>
void BTree2<T>::PreOrder( BTreeNode<T>* pNode )const
{ BTreeNode<T> **pStack;
int top = 0;
int size = GetHeight( pNode );
if(size <= 0 )return;
pStack = new (BTreeNode<T>*)[size + 1];
assert( (pStack) != NULL );
while( pNode != NULL || top != 0)
{ if( pNode != NULL )
{ BTree<T>::PutOut( pNode );
pStack[++top] = pNode;//push pNode into stack
pNode = pNode->left;//visit left child
}
else
{  pNode = pStack[top--];
pNode = pNode->right;
}
}
delete [] pStack;
}

template<class T>
void BTree2<T>::InOrder( BTreeNode<T>* pNode )const
{ BTreeNode<T> **pStack;
int top = 0;
int size = GetHeight( pNode );
if(size <= 0 )return;
pStack = new (BTreeNode<T>*)[size + 1];
assert( (pStack) != NULL );
while( pNode != NULL || top != 0)
{ if( pNode != NULL )
{ //BTree<T>::PutOut( pNode );
pStack[++top] = pNode;//push pNode into stack
pNode = pNode->left;//visit left child
}
else
{  pNode = pStack[top];
top--;
BTree<T>::PutOut( pNode );
pNode = pNode->right;
}
}
delete [] pStack;
}

template<class T>
void BTree2<T>::ClusterPoster( BTreeNode<T>* pNode )const
{
BTreeNode<T>* p;
int top = 0;
int size = GetHeight( pNode );
if(size <= 0 )return;

struct ClusterNode
{
int IsFirst;
BTreeNode<T>* pNode;
};
ClusterNode  *pStack;
pStack = new (ClusterNode )[size + 1];
assert( pStack != NULL );
p = pNode;
while( p!= NULL || top != 0 )
{ if(p != NULL )
{   top++;
pStack[top].pNode = p;
pStack[top].IsFirst = 1;
p = p->left;
}
else
{ if(pStack[top].IsFirst)
{ pStack[top].IsFirst = 0;
p = (pStack[top].pNode)->right;
}
else
{ p = pStack[top].pNode;
top--;
BTree<T>::PutOut( p );
p = NULL;
}
}
}
delete []pStack;
}

template<class T>
void BTree2<T>::Create2( const char chArray[],const int size )
GListToTree( chArray,size);
}

template<class T>
BTreeNode<T>* BTree2<T>::GListToTree( const char *pArray, const int length )
{ BTreeNode<T> **pStack;
BTreeNode<T>* rt;
BTreeNode<T>* p;
int top = 0;//point to the top of stack
int i = 1;//index of pArray

if( length < 2 )return NULL;

pStack = new (BTreeNode<T>*)[length + 1 ];
assert( pStack != NULL );
p = new BTreeNode<T>(pArray[ i ] );//apply a new node as the root of binary tree
if( p == NULL )
{ delete [] pStack ;
throw CErrMsgList( 3 );
}
rt = p;
pStack[++top] = p;//push p to stack

do
{
i++;//get the next char
if( pArray[ i ] == '(')
{ continue;
}
if( pArray[ i ] == ',' || pArray[ i ] == ')' )
{ top--;
}
else
{   if( pArray[ i ] == '*' )
{ p = NULL;
}
else
{      p = new (BTreeNode<T>)(pArray[ i ]);
if( p == NULL )
{     delete [] pStack ;
throw CErrMsgList( 3 );
}
if( pArray[ i - 1 ] == '(')
{   pStack[top]->left = p;//pStack[top] store current root node
}
else
{ pStack[top]->right = p;//problem
}

}//else
pStack[++top] = p;
}//else
}while( top != 0 );
delete  [] pStack ;
return root = rt;
}

template<class T>
int BTree2<T>::GetHeight( BTreeNode<T>* pNode )const
{ if(pNode == NULL)
return 1;
else
return int(fmax( GetHeight( pNode->left ),GetHeight( pNode->right ) ) + 1);
}

template<class T>
void BTree2<T>::Visiter()const
{ int selected;
cout<<"please input 1 to putout in preorder,2 to putout in inorder,"
<<"3 to putout in clusterorder,4 to putout in levelorder"
<<"0 to exit/n";
cin>>selected;
do{
switch( selected )
{ case 1:
PreOrder( root );
cout<<endl;
cin>>selected;
break;
case 2:
InOrder( root );
cout<<endl;
cin>>selected;
break;
case 3:
ClusterPoster( root );
cout<<endl;
cin>>selected;
break;
case 4:
// LevelOrder( root );
break;
default :
break;
}
}while(selected != 0);
}
#endif

#include <iostream>
using std::cout;
using std::endl;

#include <cmath>
#include "CBTree.h"
#include "BTree2.h"

int main(int argc, char* argv[])
{  BTree<int> bt;
//int number;
//cout<<"input 5 numbers:/n";
static const int NodeSize = 10;

for( int i =0;i < NodeSize;i++)
{// cin>>number;
bt.Create( 1 + rand()%100 );
}
bt.Visiter();

BTree2<char> bt2;
//(2(3(*,7(5,*)),9))
char GList[18] = { '(' , '2' , '(' , '3' , '(' , '*' , ',' , '7' , '(' , '5' , ',' ,
'*' , ')' , ')' , ',' , '9' , ')' , ')' };
bt2.Create2( GList,18 );
bt2.Visiter();

BTree2<float> bt3;
for( int i =0;i < NodeSize;i++)
{// cin>>number;
bt3.Create( (1 + rand()%100)*1.12 ) ;//调用基类版本
}
bt3.Visiter();
system("pause");
return 0;
}

0
0

* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
个人资料
• 访问：76592次
• 积分：1253
• 等级：
• 排名：千里之外
• 原创：48篇
• 转载：13篇
• 译文：0篇
• 评论：19条
评论排行
最新评论