二叉树的C++源码

原创 2007年09月11日 21:15:00

 参考着课件,写了一个简单的二叉树,用法很简单,方法也很少,要是谁有兴趣的话,加上一个线索二叉树的方法,就更好了。

KaKaBTree btree("-(+(a,*(b,-(c,d))),/(e,f))");//用广义表,表示法输入
 btree.Preorder();//前序遍历
 btree.Inorder();//中序遍历
 btree.Postorder();//后序遍历
 cout<<btree.Depth();//深度

KaKaBTree.h

 

#pragma once
#include 
<string>
#include 
<vector>
#include 
<iostream>
using  std::string;


typedef 
struct Note{
   
char Date;
   Note 
*Left;
   Note 
*Right;
   Note(
char char_v){
       Date
=char_v;
       Left
=0;
       Right
=0;
   }

}
*PNote;
class KaKaBTree
{
public:
    KaKaBTree(
void);
    KaKaBTree(
string s);//用广义表,表示法输入,KaKaBTree btree("-(+(a,*(b,-(c,d))),/(e,f))")    
private:
    KaKaBTree(
const KaKaBTree& bt);
    KaKaBTree 
operator=(const KaKaBTree& bt);
public:
    
void Init(string s);//用广义表,表示法输入,KaKaBTree btree("-(+(a,*(b,-(c,d))),/(e,f))")    
    void Preorder(void);//前序遍历
    void Inorder(void);//中序遍历
    void Postorder(void);//后序遍历
    int Depth(void);//深度
public:
    
~KaKaBTree(void);    
private:
    PNote BT;
    
void Clear(void);
private:
    
void Create(string s);
    
void Iner_Clear(PNote PN);
    
void Iner_Preorder(PNote pn);
    
void Iner_Inorder(PNote pn);
    
void Iner_Postorder(PNote pn);    
    
int Iner_Depth(PNote pn);
};

 

KaKaBTree.cpp

 

#include "KaKaBTree.h"
#define MAX(a,b) ((a)>(b)?(a):(b))
using std::vector;
using std::string;
using std::cout;
using std::endl;

KaKaBTree::KaKaBTree(
void):BT(0)
{
}

KaKaBTree::KaKaBTree(
string s):BT(0)
{
    
this->Create(s);    
}

KaKaBTree::
~KaKaBTree(void)
{
    
this->Clear();
}

void KaKaBTree::Init(string s)
{
    
this->Clear();
    
this->Create(s);
}



void KaKaBTree::Clear(void)
{
    
this->Iner_Clear(BT);
    BT
=0;
    
}

void KaKaBTree::Iner_Clear(PNote PN)
{
    
if(PN){        
        Iner_Clear(PN
->Left);
        Iner_Clear(PN
->Right);
        delete PN;
    }
}



void KaKaBTree::Create(string s)
{
    
//用广义表,表示法输入
    if(s.empty()) return;
    vector
<Note*> StackNote;
    
enum LR{L,R};
    LR lr
=L;
    
    BT
=new Note(s[0]);
    PNote t_p
=BT;
    
for(string::size_type i=1;i!=s.size();++i){
         
char ch=s[i];
         
switch(ch){
             
case '(':
                 StackNote.push_back(t_p);
                 lr
=L;
                 
break;
             
case ',':
                 lr
=R;
                 
break;
             
case ')':
                 StackNote.pop_back();                
                 
break;
             
default:
                 
if(lr==L){
                     t_p
= StackNote[StackNote.size()-1]->Left=new Note(ch);
                     
                 }
else{
                      t_p
= StackNote[StackNote.size()-1]->Right=new Note(ch);
                      
                 }
         }

       
    }
    

}

void KaKaBTree::Preorder(void)
{
    cout
<<endl<<"===================Preorder==================="<<endl;
    
this->Iner_Preorder(BT);
    cout
<<endl<<"==============================================="<<endl;

}
void KaKaBTree::Iner_Preorder(PNote pn)
{
    
//前序遍历
    if(pn){
        cout
<<pn->Date<<" ";
        
this->Iner_Preorder(pn->Left);        
        
this->Iner_Preorder(pn->Right);
    }
    
}

void KaKaBTree::Inorder(void)
{
    cout
<<endl<<"==================Inorder======================"<<endl;
    
this->Iner_Inorder(BT);
    cout
<<endl<<"==============================================="<<endl;
}
void KaKaBTree::Iner_Inorder(PNote pn)
{
    
//中序遍历
    if(pn){
        
this->Iner_Inorder(pn->Left);
        cout
<<pn->Date<<" ";
        
this->Iner_Inorder(pn->Right);

    }
}



void KaKaBTree::Postorder(void)
{
    cout
<<endl<<"=============Postorder========================="<<endl;
    
this->Iner_Postorder(BT);
    cout
<<endl<<"==============================================="<<endl;
}
void KaKaBTree::Iner_Postorder(PNote pn)
{
    
//后序遍历
    if(pn){
        
this->Iner_Postorder(pn->Left);        
        
this->Iner_Postorder(pn->Right);
        cout
<<pn->Date<<" ";

    }
}

int KaKaBTree::Depth(void)
{
    
return Iner_Depth(BT);
}

int KaKaBTree::Iner_Depth(PNote pn)
{
    
//深度
    if(!pn){
        
return 0;
    }
else{
        
int dl,dr;
        dl
=Iner_Depth(pn->Left);
        dr
=Iner_Depth(pn->Right);
        
return MAX(dl,dr)+1;

    }

}

 

 

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

【算法导论】C++参考源码之队列、二叉树

简单的队列实现简单 #include using namespace std; //---------------------------------------------------------...

二叉树c++源码(原创)

二叉树的递归与非递归遍历源码(C++)

#include #include #include using namespace std; struct node { node* lchild; node* rchild; ...

关于C++类库KYLib: 用C语言实现平衡二叉树(AVL tree)的源码

平衡二叉树(AVL tree)调整算法请参见我的博文: 若要在 C++ 中使用则只要将 KYAVLTreeC.c 改为 KYAVLTreeC.cpp 即可。   用C语言实现平衡二叉树(A...
  • kyee
  • kyee
  • 2011-03-05 09:28
  • 1513

用数组建立二叉树源码

  • 2011-07-17 14:52
  • 868B
  • 下载

二叉树的三种遍历算法 源码

VisitBiTree.java package biTree; import java.util.Stack; //二叉树的遍历类 public class VisitBiTree {...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)