二叉树的C++源码

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

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;

    }

}