二叉樹的創建，遍歷，查找，查找父節點，深度，大小等的遞歸實現

在計算機科學中，二叉樹（英語：Binary tree）是每個節點最多隻有兩個分支(不存在分支度大於2的節點)的樹結構。通常分支被稱作“左子樹”和“右子樹”。二叉樹的分支具有左右次序，不能顛倒。
今天我們來實現一下二叉樹的創建，三種遍歷，以及查找等。

拿這個二叉樹來說吧

#ifndef _TREE_H
#define _TREE_H

#define ElemType char
typedef struct BinTreeNode                //二叉樹節點類型
{
    ElemType data;
    BinTreeNode* leftChild;
    BinTreeNode* rightChild;
}BinTreeNode;
typedef struct          //二叉樹根結點
{
    BinTreeNode* root;
    ElemType ref;
}BinTree;

void InitBinTree(BinTree *t);       //初始化根結點
void CreateBinTree(BinTree* t);     //創建二叉樹
void CreateBinTree(BinTreeNode* &t);
void CreateBinTree(BinTree* t,const char* &p);  //根據給好的字符串創建二叉樹，畢竟每次運行都手動輸入一遍字符串太難受了
void CreateBinTree(BinTreeNode* &t,const char* &p);
void PreOrder(BinTree* t);      //前序遍歷
void PreOrder(BinTreeNode* t);
void InOrder(BinTree* t);       //中序遍歷
void InOrder(BinTreeNode* t);
void PosOrder(BinTree* t);      //後序遍歷
void PosOrder(BinTreeNode* t);
int Height(BinTree* t);         //求二叉樹的深度
int Height(BinTreeNode* t);
int Size(BinTree* t);           //求二叉樹的大小
int Size(BinTreeNode* t);
BinTreeNode* Find(BinTree* t,char key);   //根據鍵值查找所在節點
BinTreeNode* Find(BinTreeNode* t,char key);
BinTreeNode* Parent(BinTree* t,char key);  //根據鍵值查找對應父節點
BinTreeNode* Parent(BinTreeNode* t,char key);

#endif

首先是頭文件

 #include<iostream>
 using namespace std;
 #include<assert.h>
 #include"Tree.h"
void InitBinTree(BinTree *t)           //初始化根結點
{
    t->root=NULL;
    t->ref='#';
}
void CreateBinTree(BinTree* t)         //凡是參數爲BinTree* t的函數均爲用戶接口
{
    CreateBinTree(t->root);
}
void CreateBinTree(BinTreeNode* &t)     //此處爲手動輸入的創建函數，&的作用爲引用
{
    ElemType item;
    cin>>item;
    if(item=='#')
    {
        t=NULL;
    }
    else
    {
        t=(BinTreeNode*)malloc(sizeof(BinTreeNode));
        assert(t!=NULL);
        t->data=item;
        CreateBinTree(t->leftChild);
        CreateBinTree(t->rightChild);
    }
}
void PreOrder(BinTree* t)              //前序遍歷
{
    PreOrder(t->root);
}
void PreOrder(BinTreeNode* t)
{
    if(t)                              //t爲非空節點時
    {
        cout<<t->data<<" ";
        PreOrder(t->leftChild);
        PreOrder(t->rightChild);
    }
}
void InOrder(BinTree* t)          //中序遍歷
{
    InOrder(t->root);
}
void InOrder(BinTreeNode* t)
{
    if(t)   
    {
        InOrder(t->leftChild);
        cout<<t->data<<" ";
        InOrder(t->rightChild);
    }
}
void PosOrder(BinTree* t)             //後序遍歷
{
    PosOrder(t->root);
}
void PosOrder(BinTreeNode* t)
{
    if(t)
    {
        PosOrder(t->leftChild);
        PosOrder(t->rightChild);
        cout<<t->data<<" ";
    }
}
int Height(BinTree* t)
{
    return Height(t->root);
}
int  Height(BinTreeNode* t)                 //通過遞歸分別求左子數和右子樹的高度，返回較大值
{
    if(t==NULL)
        return 0;
    int leftHeight=Height(t->leftChild);
    int rightHeight=Height(t->rightChild);
    return (leftHeight>rightHeight?leftHeight:rightHeight)+1;
}
int  Size(BinTree* t)
{
    return Size(t->root);
}
int  Size(BinTreeNode* t)                  //此處也可以使用static求大小
{
    if(t==NULL)
        return 0;
    return Size(t->leftChild)+Size(t->rightChild)+1;
}
void CreateBinTree(BinTree *t, const char *&p)   //不通過手動輸入創建二叉樹，博主使用的爲ABC##DE##F##G#H##，其中#爲結束的標誌
{
    CreateBinTree(t->root, p);
}
void CreateBinTree(BinTreeNode *&t, const char *&p)
{
    if(*p=='#'||*p=='\0')
        t=NULL;
    else
    {
        t=(BinTreeNode*)malloc(sizeof(BinTreeNode));
        assert("t!=NULL");
        t->data=*p;
        CreateBinTree(t->leftChild,++p);
        CreateBinTree(t->rightChild,++p);
    }
}
BinTreeNode* Find(BinTree* t,ElemType key)  //根據鍵值求節點地質
{
    return Find(t->root,key);
}
BinTreeNode* Find(BinTreeNode* t,ElemType key)
{
    if(t==NULL)
        return NULL;
    if(t->data==key)
        return t;
    BinTreeNode* p = Find(t->leftChild,key);
    if(p)
        return p;
    return Find(t->rightChild,key);
}
BinTreeNode* Parent(BinTree* t,ElemType key)   //根據鍵值求父節點
{
    return Parent(t->root,key);
}
BinTreeNode* Parent(BinTreeNode* t,ElemType key)
{
    if(t==NULL)
        return NULL;
    BinTreeNode* p=Find(t,key);
    if(p==NULL||p==t)
        return NULL;
    if(t->leftChild==p||t->rightChild==p)
        return t;
    BinTreeNode* q=Parent(t->leftChild,key);
    if(q)
        return q;
    return Parent(t->rightChild,key);
}

頭文件中函數聲明的實現

 #include<iostream>
using namespace std;
 #include"Tree.h"

 int main()
{
    const char *p="ABC##DE##F##G#H##";
    BinTreeNode* Targe,*par;
    BinTree T;
    InitBinTree(&T);
    CreateBinTree(&T,p);
    cout<<"Pre:";
    PreOrder(&T);
    cout<<endl;
    cout<<"In:";
    InOrder(&T);
    cout<<endl;
    cout<<"Pos:";
    PosOrder(&T);
    cout<<endl;
    cout<<"Size:"<<Size(&T)<<endl;
    cout<<"Height:"<<Height(&T)<<endl;
    Targe=Find(&T,'E');
    cout<<"Find:"<<Targe->data<<endl;
    par=Parent(&T,'E');
    cout<<"Parent of E:"<<par->data<<endl;
}

主函數部分
運行結果：