二叉树递归算法

程序小白，希望和大家多交流，共同学习

//二叉树，先序创建二叉树，然后使用递归完成各种操作
//对于遍历，传递的是每个根节点对应的左右子树根节点地址,
//使用取地址符&获取根节点地址之后进行操作，但又不希望修改
//此子树，所以使用const
//后面的两个二叉树的方法，BinaryTreeNode揭示了本质，所有的操作，
//其实还是对结点的操作，剩下的只是将结点连接起来 
#include<iostream>
using namespace std;

typedef char elemType;
struct BTNode//二叉树结点组成，数据域和左右
{
    elemType data;
    BTNode *lChild, *rChild;
};

typedef BTNode *BTree;

//先序创建二叉树
void preCreateBTree(BTree &bt);
//访问二叉树的结点，返回数据域
void visit(BTNode *bt);
//先序遍历二叉树
void preOrder(const BTree &bt);
//中序遍历二叉树
void inOrder(const BTree &bt);
//后续遍历二叉树
void postOrder(const BTree &bt);
//计算叶子数
int getLeaves(const BTree &bt);
void getLeaves(const BTree &bt, int &number);
//计算树的高度
int getHeight(const BTree &bt);
void getHeight(const BTree &bt, int h, int &height);
//计算数据个数
void getNodes(const BTree &bt, int &number);

int main()
{
    //ABC#DE####F#H##
    //ABC##DE##F##G#H##
    BTree bt;
    cout << "先序创建二叉树: ";
    preCreateBTree(bt);
    cout << "\n先序遍历二叉树: ";
    preOrder(bt);
    cout << "\n中续遍历二叉树: ";
    inOrder(bt);
    cout << "\n后续遍历二叉树: ";
    postOrder(bt);
    cout << "\n计算树叶子数: ";
    cout << getLeaves(bt);
    int number = 0;
    getLeaves(bt, number);
    cout << " " << number;
    cout << "\n计算树的高度: ";
    cout << getHeight(bt);
    int length = 0;
    getHeight(bt, 1, length);
    cout << " " << length;
    cout <<"\n结点数: ";
    int count = 0;
    getNodes(bt, count);
    cout << count << endl;

    return 0;
}

//先序创建二叉树
void preCreateBTree(BTree &bt)
{
    elemType data;
    cin >> data;
    if (data == '#')
    {
        bt = NULL;
    }
    else
    {
        bt = new BTNode;
        bt -> data =  data;
        preCreateBTree(bt -> lChild);
        preCreateBTree(bt -> rChild);
    }
}
//访问二叉树的结点，返回数据域
void visit(BTNode *bt)
{
    if (bt)
    {
        cout << bt -> data;
    }
}
//先序遍历二叉树
void preOrder(const BTree &bt)
{
    if (bt != NULL)
    {
        visit(bt);
        preOrder(bt -> lChild);
        preOrder(bt -> rChild);
    }
}
//中序遍历二叉树
void inOrder(const BTree &bt)
{
    if (bt != NULL)
    {
        inOrder(bt -> lChild);
        visit(bt);
        inOrder(bt -> rChild);
    }
}
//后续遍历二叉树
void postOrder(const BTree &bt)
{
    if (bt != NULL)
    {
        postOrder(bt -> lChild);
        postOrder(bt -> rChild);
        visit(bt);
    }
}
//计算叶子数
int getLeaves(const BTree &bt)
{
    if (bt == NULL)
    {
        return 0;
    }
    else if ((bt -> lChild == NULL) && (bt -> rChild == NULL))
    {
        return 1;
    }
    else
    {
        return getLeaves(bt -> lChild) + getLeaves(bt -> rChild);
    }
}
void getLeaves(const BTree &bt, int &number)
{
    if (bt)
    {
        if ((bt -> lChild == NULL) && (bt -> rChild == NULL))
        {
            number++;
        }
        getLeaves(bt -> lChild, number);
        getLeaves(bt -> rChild, number);
    }
}
//计算树的高度
int getHeight(const BTree &bt)
{
    if (bt == NULL)
    {
        return 0;
    }

    int leftH = 0, rightH = 0, totalH = 0;
    leftH = getHeight(bt -> lChild);
    rightH = getHeight(bt -> rChild);
    totalH = leftH > rightH ? leftH : rightH;

    return totalH + 1;
}
void getHeight(const BTree &bt, int h, int &height)
{
    if (bt)
    {
        if (height < h)
        {
            height = h;
        }

        getHeight(bt -> lChild, h + 1, height);
        getHeight(bt -> rChild, h + 1, height);
    }
}
//计算数据个数
void getNodes(const BTree &bt, int &number)
{
    if (bt)
    {
        number++;
        getNodes(bt -> lChild, number);
        getNodes(bt -> rChild, number);
    }
}

//二叉树，先序创建二叉树，然后使用递归完成各种操作
#include<iostream>
using namespace std;

typedef char elemType;
struct BTNode//二叉树结点组成，数据域和左右
{
    elemType data;
    BTNode *lChild, *rChild;
};

typedef BTNode *BTree;

//先序创建二叉树
void preCreateBTree(BTree &bt);
//访问二叉树的结点，返回数据域
void visit(BTNode *bt);
//先序遍历二叉树
void preOrder(BTree bt);
//中序遍历二叉树
void inOrder(BTree bt);
//后续遍历二叉树
void postOrder(BTree bt);
//计算叶子数
int getLeaves(BTree bt);
void getLeaves(BTree bt, int &length);
//计算树的高度
int getHeight(BTree bt);
void getHeight(BTree bt, int h, int &height);
//计算数据个数
void getNodes(BTree bt, int &number);

int main()
{
    //ABC#DE####F#H##
    BTree bt;
    cout << "先序创建二叉树: ";
    preCreateBTree(bt);
    cout << "\n先序遍历二叉树: ";
    preOrder(bt);
    cout << "\n中续遍历二叉树: ";
    inOrder(bt);
    cout << "\n后续遍历二叉树: ";
    postOrder(bt);
    cout << "\n计算树叶子数: ";
    cout << getLeaves(bt);
    int number = 0;
    getLeaves(bt, number);
    cout << " " << number;
    cout << "\n计算树的高度: ";
    cout << getHeight(bt);
    int length = 0;
    getHeight(bt, 1, length);
    cout << " " << length;
    cout <<"\n结点数: ";
    int count = 0;
    getNodes(bt, count);
    cout << count << endl;
    return 0;
}

//先序创建二叉树
void preCreateBTree(BTree &bt)
{
    elemType data;
    cin >> data;
    if (data == '#')
    {
        bt = NULL;
    }
    else
    {
        bt = new BTNode;
        bt -> data =  data;
        preCreateBTree(bt -> lChild);
        preCreateBTree(bt -> rChild);
    }
}
//访问二叉树的结点，返回数据域
void visit(BTNode *bt)
{
    if (bt)
    {
        cout << bt -> data;
    }
}
//先序遍历二叉树
void preOrder(BTree bt)
{
    if (bt != NULL)
    {
        visit(bt);
        preOrder(bt -> lChild);
        preOrder(bt -> rChild);
    }
}
//中序遍历二叉树
void inOrder(BTree bt)
{
    if (bt != NULL)
    {
        inOrder(bt -> lChild);
        visit(bt);
        inOrder(bt -> rChild);
    }
}
//后续遍历二叉树
void postOrder(BTree bt)
{
    if (bt != NULL)
    {
        postOrder(bt -> lChild);
        postOrder(bt -> rChild);
        visit(bt);
    }
}
//计算叶子数
int getLeaves(BTree bt)
{
    if (bt == NULL)
    {
        return 0;
    }
    else if ((bt -> lChild == NULL) && (bt -> rChild == NULL))
    {
        return 1;
    }
    else
    {
        return getLeaves(bt -> lChild) + getLeaves(bt -> rChild);
    }
}
void getLeaves(BTree bt, int &length)
{
    if (bt)
    {
        if ((bt -> lChild == NULL) && (bt -> rChild == NULL))
        {
            length++;
        }
        getLeaves(bt -> lChild, length);
        getLeaves(bt -> rChild, length);
    }
}
//计算树的高度
int getHeight(BTree bt)
{
    if (bt == NULL)
    {
        return 0;
    }
    int leftH = 0, rightH = 0, totalH = 0;
    leftH = getHeight(bt -> lChild);
    rightH = getHeight(bt -> rChild);
    totalH = leftH > rightH ? leftH : rightH;

    return totalH + 1;
}
void getHeight(BTree bt, int h, int &height)
{
    if (bt)
    {
        if (h > height)
        {
            height = h;
        }
        getHeight(bt -> lChild, h + 1, height);
        getHeight(bt -> rChild, h + 1, height);
    }
}
//计算数据个数
void getNodes(BTree bt, int &number)
{
    if (bt)
    {
        number++;
        getNodes(bt -> lChild, number);
        getNodes(bt -> rChild, number);
    }
}

//二叉树，先序创建二叉树，然后使用递归完成各种操作
#include<iostream>
using namespace std;

typedef char elemType;
struct BTNode//二叉树结点组成，数据域和左右
{
    elemType data;
    BTNode *lChild, *rChild;
};

typedef BTNode *BTree;

//先序创建二叉树
void preCreateBTree(BTree &bt);
//访问二叉树的结点，返回数据域
void visit(BTNode *bt);
//先序遍历二叉树
void preOrder(BTNode *bt);
//中序遍历二叉树
void inOrder(BTNode *bt);
//后续遍历二叉树
void postOrder(BTNode *bt);
//计算叶子数
int getLeaves(BTNode *bt);
void getLeaves(BTNode *bt, int &number);
//计算树的高度
int getHeight(BTNode *bt);
void getHeight(BTNode *bt, int h, int &height);
//计算数据个数
void getNodes(BTNode *bt, int &number);

int main()
{
    //ABC#DE####F#H##
    BTree bt;
    cout << "先序创建二叉树: ";
    preCreateBTree(bt);
    cout << "\n先序遍历二叉树: ";
    preOrder(bt);
    cout << "\n中续遍历二叉树: ";
    inOrder(bt);
    cout << "\n后续遍历二叉树: ";
    postOrder(bt);
    cout << "\n计算树叶子数: ";
    cout << getLeaves(bt);
    int number = 0;
    getLeaves(bt, number);
    cout << " " << number;
    cout << "\n计算树的高度: ";
    cout << getHeight(bt);
    int length = 0;
    getHeight(bt, 1, length);
    cout << " " << length;
    cout <<"\n结点数: ";
    int count = 0;
    getNodes(bt, count);
    cout << count << endl;
    return 0;
}

//先序创建二叉树
void preCreateBTree(BTree &bt)
{
    elemType data;
    cin >> data;
    if (data == '#')
    {
        bt = NULL;
    }
    else
    {
        bt = new BTNode;
        bt -> data =  data;
        preCreateBTree(bt -> lChild);
        preCreateBTree(bt -> rChild);
    }
}
//访问二叉树的结点，返回数据域
void visit(BTNode *bt)
{
    if (bt != NULL)
    {
        cout << bt -> data;
    }
}
//先序遍历二叉树
void preOrder(BTNode *bt)
{
    if (bt != NULL)
    {
        visit(bt);
        preOrder(bt -> lChild);
        preOrder(bt -> rChild);
    }
}
//中序遍历二叉树
void inOrder(BTNode *bt)
{
    if (bt != NULL)
    {
        inOrder(bt -> lChild);
        visit(bt);
        inOrder(bt -> rChild);
    }
}
//后续遍历二叉树
void postOrder(BTNode *bt)
{
    if (bt != NULL)
    {
        postOrder(bt -> lChild);
        postOrder(bt -> rChild);
        visit(bt);
    }
}
//计算叶子数
int getLeaves(BTNode *bt)
{
    if (bt == NULL)
    {
        return 0;
    }
    else if ((bt -> rChild == NULL) && (bt -> rChild == NULL))
    {
        return 1;
    }
    else
    {
        return getLeaves(bt -> lChild) + getLeaves(bt -> rChild);
    }
}
void getLeaves(BTNode *bt, int &number)
{
    if (bt)
    {
        if ((bt -> lChild == NULL) && (bt -> rChild == NULL))
        {
            number++;
        }
        getLeaves(bt -> lChild, number);
        getLeaves(bt -> rChild, number);
    }
}
//计算树的高度
int getHeight(BTNode *bt)
{
    if (bt == NULL)
    {
        return 0;
    }

    int leftH = 0, rightH = 0, totalH = 0;;
    leftH = getLeaves(bt -> lChild);
    rightH = getLeaves(bt -> rChild);
    totalH = leftH > rightH ? leftH : rightH;

    return totalH + 1;
}
void getHeight(BTNode *bt, int h, int &height)
{
    if (bt)
    {
        if (h > height)
        {
            height = h;
        }
        getHeight(bt -> lChild, h + 1, height);
        getHeight(bt -> rChild, h + 1, height);
    }
}
//计算数据个数
void getNodes(BTNode *bt, int &number)
{
    if (bt)
    {
        number++;
        getNodes(bt -> lChild, number);
        getNodes(bt -> rChild, number);
    }
}