二叉树创建、前序遍历、中序遍历、后序遍历

#ifndef BINARYTREE_H
#define BINARYTREE_H

typedef struct TreeData{
    TreeData * left_child = nullptr;
    TreeData * right_child = nullptr;
    char data;
}_TreeData_;

class BinaryTree
{
public:
    BinaryTree();

    void create_node(TreeData *&root);

    TreeData *create_node(char ldr_order[], char lrd_order[], int n);

    void pre_traverse(TreeData *node);

    void mid_traverse(TreeData *node);

    void post_traverse(TreeData *node);

};

#endif // BINARYTREE_H

#include "binarytree.h"
#include <iostream>

BinaryTree::BinaryTree()
{

}

void BinaryTree::create_node(TreeData *&root)
{
    char c;
    std::cin >> c;
    if (c == '#')
    {
        root = nullptr;
    }
    else
    {
        root = new TreeData();
        root->data = c;
        create_node(root->left_child);
        create_node(root->right_child);
    }
}

/*
把中序，后序分割左右节点依次递归
*/
TreeData * BinaryTree::create_node(char ldr_order[], char lrd_order[], int n)
{
    if (n == 0) return nullptr;
    TreeData *td = new TreeData();
    td->data = lrd_order[n-1];

    char left_ldr[n] = {};
    char right_ldr[n] = {};

    int n1 = 0; int n2 = 0;
    for (int k = 0; k < n; ++k)
    {
        if (ldr_order[k] != td->data)
        {
            if (n1 >= k)
                left_ldr[n1++] = ldr_order[k];
            else
                right_ldr[n2++] = ldr_order[k];
        }
    }
    int m1 = 0; int m2 = 0;
    char left_lrd[n] = {};
    char right_lrd[n] = {};
    for (int k = 0; k < n-1; ++k)
    {
        if (k < n1)
            left_lrd[m1++] = lrd_order[k];
        else
            right_lrd[m2++] = lrd_order[k];
    }
    td->left_child = create_node(left_ldr, left_lrd, n1);
    td->right_child = create_node(right_ldr, right_lrd, n2);

    return td;
}

void BinaryTree::pre_traverse(TreeData *node)
{
    if (!node) return;
    std::cout << node->data << ",";
    pre_traverse(node->left_child);
    pre_traverse(node->right_child);
}

void BinaryTree::mid_traverse(TreeData *node)
{
    if (!node) return;
    mid_traverse(node->left_child);
    std::cout << node->data << ",";
    mid_traverse(node->right_child);
}

void BinaryTree::post_traverse(TreeData *node)
{
    if (!node) return;
    post_traverse(node->left_child);
    post_traverse(node->right_child);
    std::cout << node->data << ",";
}

#include <iostream>
#include "binarytree.h"

int main(int , char **)
{
    char ldr[] = {"abcefghd"};
    char lrd[] = {"abfhgedc"};

    BinaryTree bt;
    TreeData *td = bt.create_node(ldr, lrd, 8);
    bt.pre_traverse(td);
    std::cout << std::endl;

    bt.mid_traverse(td);
    std::cout << std::endl;

    bt.post_traverse(td);
    std::cout << std::endl;
return 0;
}