二叉树基础操作总结

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/hansionz/article/details/81908134

1.定义数据结构

//二叉树
typedef char BTDataType;    
typedef struct BinaryTreeNode
{
    BTDataType _data;
    struct BinaryTreeNode* _left;
    struct BinaryTreeNode* _right;
}BTNode;

---

2.各个函数接口声明

//创建一个二叉树结点
BTNode* BuyBTNode(BTDataType x);
//创建一颗二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int *pi);
//销毁二叉树
void BinaryTreeDestroy(BTNode** newnode);
//二叉树结点个数(递归版本)
int BinaryTreeSize(BTNode* root);
//二叉树结点个数(设置全局变量，遍历一遍二叉树累加)
void BinaryTreeSize_C(BTNode* root);
//叶子节点个数
int BinaryTreeLeafSzie(BTNode* root);
//叶子结点个数(设置全局变量，遍历一遍二叉树符合条件则累加)
void BinaryTreeLeafSzie_C(BTNode* root);
//先序遍历(递归版本)
void BinaryTreePrevOrder_R(BTNode* root);
//中序遍历(递归版本)
void BinaryTreeMidOrder_R(BTNode* root);
//后序遍历(递归版本)
void BinaryTreePostOrder_R(BTNode* root);
//二叉树的高度
int BinaryTreeHigh(BTNode* root);
//返回结点的双亲结点
BTNode* BinaryTreeFindParent(BTNode* root, BTDataType x);
//第k层结点的个数
int BinaryTreeLevelKSize(BTNode* root, int k);

---

3.函数实现

//创建一个二叉树结点
BTNode* BuyBTNode(BTDataType x)
{
    BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
    if (newnode != NULL)
    {
        newnode->_data = x;
        newnode->_left = NULL;
        newnode->_right = NULL;
    }
    return newnode;
}
//给一个前序序列，创建一个二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int *pi)
{
    if (a[*pi] != '#')
    {
        BTNode* root = BuyBTNode(a[*pi]);
        //递归建立左子树
        ++(*pi);
        root->_left = BinaryTreeCreate(a, n, pi);
        //递归建立右子树
        ++(*pi);
        root->_right = BinaryTreeCreate(a, n, pi);

        return root;
    }
    else
    {
        return NULL;
    }
}
//销毁二叉树(要用后序遍历销毁，如果用前序或者中序把根节点销毁了就会找不到其他结点)
void BinaryTreeDestroy(BTNode** newnode)
{
    BTNode* root = *newnode;
    if (root == NULL)
    {
        return;
    }
    BinaryTreeDestroy(&root->_left);

    BinaryTreeDestroy(&root->_right);
    free(root);
    root = NULL;
}
//结点个数
int BinaryTreeSize(BTNode* root)
{
    //如果根节点为空，返回0
    if (root == NULL)
    {
        return 0;
    }
    //否则返回1加左子树的结点在加上右字数的结点
    return BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right) + 1;
}
//定义一个全局变量，遍历累加
int size = 0;
void BinaryTreeSize_C(BTNode* root)
{
    if (root == NULL)
    {
        return;
    }
    size++;
    BinaryTreeSize_C(root->_left);
    BinaryTreeSize_C(root->_right);
}
//叶子结点的个数
int BinaryTreeLeafSzie(BTNode* root)
{
    if (root == NULL)
    {
        return 0;
    }
    if ((root->_left == NULL) && (root->_right == NULL))
    {
        return 1;
    }
    return BinaryTreeLeafSzie(root->_left) + BinaryTreeLeafSzie(root->_right);
}
//定义全局变量，遍历符合条件的则累加
void BinaryTreeLeafSzie_C(BTNode* root)
{
    if (root == NULL)
    {
        return;
    }
    if ((root->_left == NULL) && (root->_right == NULL))
    {
        size++;
    }
    BinaryTreeLeafSzie_C(root->_left);
    BinaryTreeLeafSzie_C(root->_right);
}
//前序遍历
void BinaryTreePrevOrder_R(BTNode* root)
{
    //树为空，直接返回
    if (root == NULL)
    {
        return;
    }
    //访问根
    printf("%c", root->_data);
    //递归访问左子树
    BinaryTreePrevOrder_R(root->_left);
    //递归访问右子树
    BinaryTreePrevOrder_R(root->_right);
}
//中序遍历
void BinaryTreeMidOrder_R(BTNode* root)
{
    //树为空，直接返回
    if (root == NULL)
    {
        return;
    }
    //递归访问左子树
    BinaryTreeMidOrder_R(root->_left);
    //访问根
    printf("%c", root->_data);
    //递归访问右子树
    BinaryTreeMidOrder_R(root->_right);
}
//后序遍历
void BinaryTreePostOrder_R(BTNode* root)
{
    //树为空，直接返回
    if (root == NULL)
    {
        return;
    }
    //递归访问左子树
    BinaryTreePostOrder_R(root->_left);
    //递归访问右子树
    BinaryTreePostOrder_R(root->_right);
    //访问根
    printf("%c", root->_data);
}
//二叉树的高度(比较左右子树那个高，高的加1既为二叉树的高度)
int BinaryTreeHigh(BTNode* root)
{
    if (root == NULL)
    {
        return 0;
    }
    int ret1 = BinaryTreeHigh(root->_left);
    int ret2 = BinaryTreeHigh(root->_right);

    return ret1 > ret2 ? ret1 + 1 : ret2 + 1;
}
//返回结点的双亲结点
BTNode* BinaryTreeFindParent(BTNode* root, BTDataType x)
{
    if ((root == NULL) || (root->_data == x))
    {
        return NULL;
    }
    if (root->_left)
    {
        if (root->_left->_data == x)
        {
            return root;
        }
    }
    if (root->_right)
    {
        if (root->_right->_data == x)
        {
            return root;
        }
    }
    BTNode* ret = BinaryTreeFindParent(root->_left, x);
    if (ret)
        return ret;
    ret = BinaryTreeFindParent(root->_right, x);
    if (ret)
        return ret;
    return NULL;
}
//第K层有多少结点(左子树的K-1层加上右子树的K-1层)
int BinaryTreeLevelKSize(BTNode* root, int k)
{
    if (root == NULL)
    {
        return 0;
    }
    if (k == 1)
    {
        return 1;
    }
    return BinaryTreeLevelKSize(root->_left, k - 1) + BinaryTreeLevelKSize(root->_right, k - 1);
}