基於左子結點/右兄弟結點表示法和二叉鏈表來實現二叉樹ADT

實現二叉樹的ADT需要分別實現結點ADT和樹ADT，同時也要保證其封裝性

二叉鏈表

樹結點ADT的聲明以及實現

（1）每一個結點包括其要儲存的數據以及左右子節點的指針，通常一顆二叉樹中只有根結點能被直接訪問，所以要把數據以及子節點的指針設為private

（2）成員函數要包括：

• 構造函數，析構函數（也可以不寫）
• 獲取和設置結點內儲存的數據，左子節點，右子節點　　　
• 判斷該節點是否為葉子節點

#ifndef _BINNODE_HPP_
#define _BINNODE_HPP_
#include<iostream>
using namespace std;
class BinNode{
    private:
            char data;
            BinNode *lc;
            BinNode *rc;
    public:
            BinNode(char dataval,BinNode *l=NULL,BinNode* r=NULL){data=dataval;lc=l;rc=r;}
            BinNode(BinNode *l=NULL,BinNode* r=NULL){lc=l;rc=r;}
            void setLeftChild(BinNode *l){lc=l;}
            void setRightChild(BinNode *r){rc=r;}
            void setdata(char d){data=d;}
            BinNode *getlc(){return lc;}
            BinNode *getrc(){return rc;}
            char getdata(){return data;}
            bool isLeaf(){return lc==NULL&&rc==NULL;}
};    
#endif

樹ADT的聲明

成員變量：根結點

基本操作：獲取樹的高度，結點數目，前序/中序/后序遍歷，設置根節點的值，撤銷整棵樹

#ifndef _BINTREE_HPP_
#define _BINTREE_HPP_
#include "BinNode.hpp"
#include <iostream>
using namespace std;
class BinTree{
    public:
            BinNode * root;
            int depth(BinNode*);
            int count(BinNode*);
            void setroot(BinNode*);
            void clear(BinNode*);
            void preorder(BinNode*,void(*visit)(BinNode*));
            void inorder(BinNode*,void(*visit)(BinNode*));
            void postorder(BinNode*,void(*visit)(BinNode*));
};
#endif

樹ADT的實現

樹很多操作都需要用到遞歸，學會運用遞歸是實現這些基本操作的必要條件

而遞歸可以使用棧來模擬，所以只要理解好了棧就很好理解遞歸操作了，這里就不贅述了

前序遍歷：根節點->左子樹->右子樹

中序遍歷：左子樹->根節點->右子樹

后序遍歷：左子樹->右子樹->根節點

這三種遍歷實現方法大同小異，不同點就在於訪問的先后順序不同罷了

簡單的描述一下過程（嘗試用棧的知識去理解，先進先出）：把遞歸函數看作是一個元素，若要執行某一層的遞歸函數，則將該函數入棧，如果函數執行過程中碰到終止條件則終止函數進程即彈棧，反復進行直到棧為空，即所有的函數都被執行完

獲取樹的高度以及結點的個數也要使用遞歸，代碼的也大同小異

#include "BinTree.hpp"
void BinTree::preorder(BinNode* r,void (*visit)(BinNode* c)){
    if(r==NULL)return ;
    visit(r);
    preorder(r->getlc(),visit);
    preorder(r->getrc(),visit);
}
void BinTree::inorder(BinNode* r,void (*visit)(BinNode* c)){
    if(r==NULL)return ;
    inorder(r->getlc(),visit);
    visit(r);
    inorder(r->getrc(),visit);
}
void BinTree::postorder(BinNode* r,void (*visit)(BinNode* c)){
    if(r==NULL)return ;
    postorder(r->getlc(),visit);
    postorder(r->getrc(),visit);
    visit(r);
}
void BinTree::setroot(BinNode* r){
    root=r;
}
void BinTree::clear(BinNode*r){
    if(r==NULL)return;
    clear(r->getlc());
    clear(r->getrc());
    delete r;
}
int BinTree::depth(BinNode* r){
    int lh=0,rh=0;
    if(r!=NULL)
    {
        lh=depth(r->getlc());
        rh=depth(r->getrc());
        return (lh>rh?lh:rh)+1;
     } 
    else return 0;
}
int BinTree::count(BinNode*r){
    if(r==NULL)return 0;
    return (count(r->getlc())+count(r->getrc()))+1;
}

 demo程序

此部分首先碰到的問題就是如何構造一個二叉樹了，構造二叉樹有很多種方法，這里采用前序遍歷的方法來實現

 

#include"BinTree.hpp"
#include"BinTree.cpp"
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
BinNode* r;
BinTree T;
char s[1000];
int cnt=0;
void visit(BinNode*r);
BinNode * creatTree(char c);
void input();
int main()
{
    input();
    printf("輸出樹的深度：");
    printf("%d",T.depth(r));
    printf("\n");
    printf("輸出樹的結點個數："); 
    printf("%d",T.count(r));
    printf("\n");
    printf("按前序遍歷輸出結果\n");
    T.preorder(r,visit);
    printf("\n");
    printf("按中序遍歷輸出結果\n");
    T.inorder(r,visit);
    printf("\n");
    printf("按后序遍歷輸出結果\n");
    T.postorder(r,visit);
    printf("\n");
    return 0;
}
void visit(BinNode*r){
    printf("%c",r->getdata());
}
BinNode * creatTree(char c){
    BinNode* temp;
    if(c=='/') temp=NULL;
    else
    {
        temp=new BinNode;
        temp->setdata(c);
        c=s[++cnt];
        temp->setLeftChild(creatTree(c));
        c=s[++cnt];
        temp->setRightChild(creatTree(c));
    }
    T.setroot(temp);
    return temp; 
}
void input(){
    printf("輸入的注意事項\n");
    printf("（1）使用前序遍歷的順序輸入\n");
    printf("（2）空節點以'/'替代\n");
    printf("（3）輸入只有一行\n");
    printf("（4）輸入的數據類型都為char\n");
    printf("（5）輸入樣例：AB/D//CEG///FH//I//\n\n");
    printf("請輸入二叉樹\n"); 
    scanf("%s",s);
    r=creatTree(s[0]);
}

左子節點右兄弟節點

樹節點ADT

成員變量：節點存儲的數據，左子節點的指向，父節點的指向，右兄弟節點的指向

成員函數：跟二叉鏈表很相似，都包括構造函數，獲取，設置函數，但是少了判斷是否為葉子節點的函數，因為僅僅根據以上已知的東西無法判斷是否為葉子節點

#ifndef _BINNODE_HPP_
#define _BINNODE_HPP_
#include <iostream>
using namespace std;
class BinNode{
    private:
        char data;
        int parent;
        int lc;
        int rightbro;
    public:
        BinNode(){data='/';parent=-1;lc=-1;rightbro=-1;}
        void setdata(char d){data=d;}
        void setparent(int p){parent=p;}
        void setLc(int l){lc=l;}
        void setRightbro(int r){rightbro=r;}
        char getData(){return data;}
        int getParent(){return parent;}
        int getLc(){return lc;}
        int getRightbro(){return rightbro;}
};
#endif

樹ADT的聲明

與二叉鏈表大同小異，只是實現的方法不同罷了，這里不多加贅述了

#ifndef _BINTREE_HPP_
#define _BINTREE_HPP_
#include "BinNode.hpp"
#include <iostream>
using namespace std;
class BinTree{
    public:
        BinNode node[1024+10];
        int depth(int );
        int count(int );
        void preorder(int ,void(*visit)(BinNode no));
        void inorder(int ,void(*visit)(BinNode no));
        void postorder(int ,void(*visit)(BinNode no));
};
#endif

樹ADT的實現

這里注意一個問題：

遍歷操作的終止條件多了一項，因為左子節點右兄弟節點使用數組來實現的，所以數組的下標有很大的作用，稍不注意就可能越界

#include "BinTree.hpp"
void BinTree::preorder(int n,void(*visit)(BinNode no)){
    if(node[n].getData()=='/'||n==-1)return;
    visit(node[n]);
    preorder(node[n].getLc(),visit);
    preorder(node[node[n].getLc()].getRightbro(),visit);
}
void BinTree::inorder(int n,void(*visit)(BinNode no)){
    if(node[n].getData()=='/'||n==-1)return;    
    inorder(node[n].getLc(),visit);
    visit(node[n]);
    inorder(node[node[n].getLc()].getRightbro(),visit);
}
void BinTree::postorder(int n,void(*visit)(BinNode no)){
    if(node[n].getData()=='/'||n==-1)return;    
    postorder(node[n].getLc(),visit);
    postorder(node[node[n].getLc()].getRightbro(),visit);
    visit(node[n]);
}
int BinTree::count(int n){
    if(node[n].getData()=='/'||n==-1)return 0;
    return count(node[n].getLc())+count(node[node[n].getLc()].getRightbro())+1;
}
int BinTree::depth(int n){
    if(node[n].getData()=='/'||n==-1)return 0;
    int lh=depth(node[n].getLc());
    int rh=depth(node[node[n].getLc()].getRightbro());
    return (lh>rh?lh:rh)+1;
}

demo程序

（1）在構造一顆二叉樹時使用的是按層次遍歷的順序，使用其他的順序都不好構造

（2）在構造函數的時候，注意可以利用二叉樹的性質，比如左節點的下標一定是奇數，左子節點的下標與父節點的下標之間的關系，兄弟節點之間下標之間的關系

弄清楚這些后就很容易的按照層次遍歷的順序構造好一顆二叉樹

我比較懶，這里就沒有考慮父節點的指向了

#include "BinTree.hpp"
#include "BinTree.cpp"
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<cstring>
using namespace std;
char s[1000];
int cnt=0;
BinTree T;
int n=0,m=0;
void visit(BinNode n){
    printf("%c",n.getData());
}
void creatTree(BinTree &t){
    for(int i=0;i<=1024;i++){
        t.node[i].setdata('/');
    }
    for(int i=0;s[i]!='\0';i++){
        t.node[i].setdata(s[i]);
        if(s[i]=='/')continue;
        t.node[i].setLc((2*i)+1);
        if((i+1)%2==0&&i!=0)t.node[i].setRightbro(i+1);
    }
}
void input(){
    printf("輸入的注意事項\n");
    printf("（1）使用層次遍歷的順序輸入\n");
    printf("（2）空節點以'/'替代\n");
    printf("（3）輸入只有一行\n");
    printf("（4）輸入的數據類型都為char\n");
    printf("（5）輸入的樹的結點要么是葉子結點要么必有左子結點\n");
    printf("（7）輸入樣例ABCD/E/FG//HI//\n\n");
    printf("請輸入二叉樹\n"); 
    scanf("%s",s);
    creatTree(T);
}
int main()
{
        input();
        printf("輸出樹的深度：");
        printf("%d",T.depth(0));
        printf("\n");
        printf("輸出樹的結點個數："); 
        printf("%d",T.count(0));
        printf("\n");
        printf("按前序遍歷輸出結果\n");
        T.preorder(0,visit);
        printf("\n");
        printf("按中序遍歷輸出結果\n");
        T.inorder(0,visit);
        printf("\n");
        printf("按后序遍歷輸出結果\n");
        T.postorder(0,visit);
        printf("\n");
        return 0;
}