二叉树的C/C++实现

二叉树的C/C++实现

---

【类BiTree下的变量注释】

root
类型: BiTree *
存储了这个节点所属的树的最上层根节点地址，同时也是用来做节点身份认证的方式。很多
成员函数都会验证root是否为空，若为空认为是不正常的节点，不会对其进行操作，保证程
序稳定性。

data
类型: ElemType
存储了节点的值，ElemType默认为int，可以通过更改BiTree.cpp里的typedef更改为其他类型。

Lptr
类型: BiTree *
存储了节点的左子节点地址，左子节点不存在时为空。

Rptr
类型: BiTree *
存储了节点的右子节点地址，右子节点不存在时为空。

【类BiTree下的函数注释】

****** 树操作函数部分********

bool BiTree::InitTree()
生成一棵树并分配一个根节点在堆区

bool BiTree::ClearTree()
将以当前节点为根节点的树的所有值重置为初始值，初始值通过宏定义确定（ElemType为int时使用）

int BiTree::GetSize()
获得以当前节点为根节点的树的节点数目

int BiTree::GetDepth()
获得以当前节点为根节点的树的深度

bool BiTree::IsEmptyTree()
判断以当前节点为根节点的树是否为空，是则返回true

bool BiTree::DestroyTree()
摧毁以当前节点为根节点的树，释放所有的内存空间

bool BiTree::ShowTree()
将整棵树通过先序遍历调用visit()展示出来

bool BiTree::TraverseTree(bool (*F)(), int flag)
遍历整棵树，并且按照函数F操作，flag可以取PRE_ORDER，IN_ORDER，POST_ORDER

*****节点操作函数部分********

BiTree* BiTree::GetRoot()
返回当前节点所在（最高层）树的根节点值

bool BiTree::Grow()
为当前结点添加左右两个新的子节点。当左右子节点都存在时返回false。

bool BiTree::IsParent()
判断当前节点是否为根节点（拥有子节点）,是则返回true。

ElemType BiTree::GetValue()
返回当前节点的值

bool BiTree::visit()
在输出窗口输出当前节点的值和它的左右子节点地址

bool BiTree::AssignValue(ElemType value)
把value赋值给当前节点的data

BiTree* BiTree::LeftChild()
返回当前节点的左子节点指针

BiTree* BiTree::RightChild()
返回当前节点的右子节点指针

bool BiTree::InsertRight(BiTree* r)
将输入r指向的节点作为当前的节点的左子节点；如果当前节点已经有了左子节点，则将原左子节点
作为r指向节点的新的左节点，实现在当前节点左侧插入一个节点的功能。

bool BiTree::InsertLeft(BiTree* l)
将输入l指向的节点作为当前的节点的左子节点；如果当前节点已经有了左子节点，则将原左子节点
作为l指向节点的新的左节点，实现在当前节点左侧插入一个节点的功能。

bool BiTree::InsertLeft()
函数重载，没有输入参数时，为当前结点添加新的左子节点。

bool BiTree::InsertRight()
函数重载，没有输入参数时，为当前结点添加新的右子节点。

bool BiTree::DeleteLeft()
删除当前节点的左子节点

bool BiTree::DeleteRight()
删除当前节点的右子节点

---

/****************************************************************
// Binary Tree Using C/C++
// File: BiTree.cpp
// Time: 2017.6.12 14:24
// Author: JayRoxis
*****************************************************************/

#ifndef __BITREE_H__
#define __BITREE_H__

#include <stdlib.h>

// Typedef
typedef int ElemType;  //Change the definition of ElemType

// Define class Bitree
typedef class BiTree{
    private:
        BiTree* root;
        ElemType data;
        BiTree* Lptr;
        BiTree* Rptr;

    public:

        // Tree related
        bool InitTree();
        bool DestroyTree();
        bool ResetTree();
        bool ClearTree();
        bool IsEmptyTree();
        bool ShowTree();
        int GetSize();
        int GetDepth();
        bool TraverseTree(bool (*F)(), int flag);

        // Tree nodes related
        bool Grow();
        BiTree* GetRoot();
        bool IsParent();
        ElemType GetValue();
        bool visit();
        bool AssignValue(ElemType value);
        BiTree* LeftChild();
        BiTree* RightChild();
        bool InsertLeft(BiTree* l);
        bool InsertRight(BiTree* r);
        bool InsertLeft();   // OVERLOAD
        bool InsertRight();  // OVERLOAD
        bool DeleteLeft();
        bool DeleteRight();
        BiTree();

} Bitree;

#endif

/****************************************************************
// Binary Tree Using C/C++
// File: BiTree.cpp
// Time: 2017.6.12 14:23
// Author: JayRoxis
*****************************************************************/

#include <stdio.h>
#include "BiTree.h"

#ifndef __BITREE_CPP__
#define __BITREE_CPP__

#define INIT_DATA 0   // Define the initial value of a tree

#define PRE_ORDER 0   // Define the traverse symbol 
#define IN_ORDER 1
#define POST_ORDER 2
#define LEVEL_ORDER 3


// Initiating
BiTree::BiTree():root(NULL),data(INIT_DATA),Lptr(NULL),Rptr(NULL){};

/************* Tree related function definition ******************/

// Initiate a binary tree, create the root node
bool BiTree::InitTree(){
    root = (BiTree *)malloc(sizeof(BiTree));
    if (!root)
        return false;
    return true;
} 


// Destroy the binary tree
bool BiTree::DestroyTree(){
    if (root)
        if (ResetTree()){
            free(root);
            root = NULL;
            return true;
        }
    return false;
}


// Reset the binary tree
bool BiTree::ResetTree(){
    if (root){
        if (Lptr){
            Lptr->ResetTree();
            DeleteLeft();
        }
        if (Rptr){
            Rptr->ResetTree();
            DeleteRight();
        }
        return true;
    }
    root->data = 0;
    return false;
}


// Clear the binary tree
bool BiTree::ClearTree(){
    if (root)
        if (AssignValue(INIT_DATA)){
            if (Lptr)
                Lptr->AssignValue(INIT_DATA);
            if (Rptr)
                Rptr->AssignValue(INIT_DATA);
            return true;
        }
    return false;
}


// Determine if the tree is empty
bool BiTree::IsEmptyTree(){
    if (root->Lptr || root->Rptr)
        return false;
    return true;
}


// Traverse the tree
bool BiTree::TraverseTree(bool (*F)(), int flag){
    if (root)
            switch (flag){
            case PRE_ORDER:         // PreOrder
                if (!F())
                    return false;
                if (Lptr)
                    if (!TraverseTree(F, flag))
                        return false;
                if (Rptr)
                    if (!TraverseTree(F, flag))
                        return false;
                return true;
                break;
            case IN_ORDER:          // InOrder              
                if (Lptr)
                    if (!TraverseTree(F, flag))
                        return false;
                if (!F())
                    return false;
                if (Rptr)
                    if (!TraverseTree(F, flag))
                        return false;
                break;
            case POST_ORDER:        // PostOrder
                if (Lptr)
                    if (!TraverseTree(F, flag))
                        return false;
                if (Rptr)
                    if (!TraverseTree(F, flag))
                        return false;
                if (!F())
                        return false;
                return true;
                break;
            case LEVEL_ORDER:       // LevelOrder
                break;
            default:
                return false;

            }
    return false;
}


// Show all the element of the tree
bool BiTree::ShowTree(){
    if (root)
        if (AssignValue(INIT_DATA)){
            if (Lptr)
                Lptr->ShowTree();
            if (Rptr)
                Rptr->ShowTree();
            visit();
            return true;
        }
    return false;
}


// Get the size of the tree
int BiTree::GetSize(){
    if (!root)
        return 0;
    return (Lptr != NULL) * Lptr->GetSize() + (Rptr != NULL) * Rptr->GetSize() + 1;
}


// Get the depth of the tree
int BiTree::GetDepth(){
    if (!root)
        return 0;
    int l = (Lptr != NULL) * Lptr->GetDepth();
    int r = (Rptr != NULL) * Rptr->GetDepth();
    return (l>=r)*l + (r>l)*r + 1;
}


/**************** Node related function definition ******************/

// Get the root of the tree
BiTree* BiTree::GetRoot(){
    return root;
}

// Create a node to a existed tree
bool BiTree::Grow(){
    if (!root)
        return false;
    if (!InsertLeft())
        if (!InsertRight())
            return false;
    return true;
}


// Determine if the node has children
bool BiTree::IsParent(){
    if (Lptr||Rptr)
        return true;
    return false;
}


// Get the value of the node
ElemType BiTree::GetValue(){
    if (!root)
        return false;
    return data;
}


// Print the value of node
bool BiTree::visit(){
    if (!root)
        return false;
    if ((Lptr)||(Rptr))
        printf("%d(%x,%x)\n",data,Lptr,Rptr);
    else
        printf("%d\n",data);
    return true;
}


// Assign value to the node
bool BiTree::AssignValue(ElemType value){
    if (!root)
        return false;
    data = value;
    if (!data == value)
        return false;
    return true;
}


// Get left child of the node
BiTree* BiTree::LeftChild(){
    return Lptr; 
}


// Get right child of the node
BiTree* BiTree::RightChild(){
    return Rptr; 
}


// Insert/Append an existed node as left child 
bool BiTree::InsertLeft(BiTree* l){
    if ((!root)||(!l))
        return false;
    if (Lptr){
        l->Lptr = Lptr;
    }
    Lptr = l;
    l->root = root;
    return true;
}


// Insert/Append an existed node as right child
bool BiTree::InsertRight(BiTree* r){
    if ((!root)||(!r))
        return false;
    if (Rptr){
        r->Rptr = Rptr;
    }
    Rptr = r;
    r->root = root;
    return true;
}


// OVERLOAD: Insert/Append an new node as left child 
bool BiTree::InsertLeft(){
    if ((!root)||(Lptr))
        return false;
    Lptr = (BiTree *)malloc(sizeof(BiTree));
    return true;
}


// OVERLOAD: Insert/Append an new node as right child 
bool BiTree::InsertRight(){
    if ((!root)||(Rptr))
        return false;
    Rptr = (BiTree *)malloc(sizeof(BiTree));
    return true;
}

// Delete left child of the node
bool BiTree::DeleteLeft(){
    if ((!root)||(!Lptr))
        return false;
    free(Lptr);
    Lptr = NULL;
    return true;
}


// Delete right child of the node
bool BiTree::DeleteRight(){
    if ((!root)||(!Rptr))
        return false;
    free(Rptr);
    Rptr = NULL;
    return true;
}

#endif