构造二叉树，打印二叉树图形

#include <iostream>
#include <cmath>
using namespace std;
struct node
{
    char c;
    int n;
    int level;
    struct node* lc;
    struct node* rc;
};
char pre[100];
char in[100];
char post[100];
struct node* create_node()
{
    struct node* p = new struct node;
    p->lc = p->rc = NULL;
    return p;
}
struct node* build_in_post(int s1, int e1, int s2, int e2)
{
    struct node* p = create_node();
    for (int i = s1; i <= e1; i++)
    {
        if (post[e2] == in[i])
        {
            p->c = post[e2];
            if (i != s1)
            {
                p->lc = build_in_post(s1, i - 1, s2, s2 + i - s1 - 1);
            }
            if (i != e1)
            {
                p->rc = build_in_post(i + 1, e1, e2 - e1 + i, e2 - 1);
            }
            break;
        }
    }
    return p;
}
struct node* build_pre_in(int s1, int e1, int s2, int e2)
{
    struct node* p = create_node();
    for (int i = s2; i <= e2; i++)
    {
        if (pre[s1] == in[i])
        {
            p->c = pre[s1];
            if (i != s2)
            {
                p->lc = build_pre_in(s1 + 1, s1 + i - s2, s2, i - 1);
            }
            if (i != e2)
            {
                p->rc = build_pre_in(s1 + i - s2 + 1, e1, i + 1, e2);
            }
            break;
        }
    }
    return p;
}
void pre_tra(struct node* t)
{
    if (t)
    {
        cout << t->n << " ";
        if (t->lc)
            pre_tra(t->lc);
        if (t->rc)
            pre_tra(t->rc);
    }
}
void in_tra(struct node* t)
{
    if (t)
    {
        if (t->lc)
            in_tra(t->lc);
        cout << t->n << " ";
        if (t->rc)
            in_tra(t->rc);
    }
}
void post_tra(struct node* t)
{
    if (t)
    {
        if (t->lc)
            post_tra(t->lc);
        if (t->rc)
            post_tra(t->rc);
        cout << t->n <<" ";
    }
}
int get_h(struct node* t)
{
    if (t)
    {
        return get_h(t->lc) > get_h(t->rc) ? get_h(t->lc) + 1 : get_h(t->rc) + 1;
    }
    return 0;
}
int find_max(struct node* t)
{
    if (t->rc)
        return(find_max(t->rc));
    else
        return t->n;
}
int find_min(struct node* t)
{
    if (t->lc)
        return(find_min(t->lc));
    else
        return t->n;
}
void print_tree_int(struct node* t)
{
    if (t)
    {
        struct node* q1[100];
        int r1 = -1;
        int f1 = -1;    
        t->level = 1;
        q1[++f1] = t;
        int max_level = get_h(t);
        while (r1 != f1)
        {    
            struct node* p = q1[++r1];
            if (p->n == 0)
            {
                        if (p->level == max_level)break;
                        q1[++f1] = create_node();
                        q1[f1]->n = 0;
                        q1[f1]->level = p->level + 1;
                        q1[++f1] = create_node();
                        q1[f1]->n = 0;
                        q1[f1]->level = p->level + 1;
            }
            else
            {
                if (p->level == max_level)break;
                if (p->lc)
                {
                    p->lc->level = p->level + 1;
                    q1[++f1] = p->lc;
                }
                else
                {
                    struct node* pt = create_node();
                    if (pt != NULL)
                    {
                        pt->n = 0;
                        pt->level = p->level + 1;
                        q1[++f1] = pt;
                    }

                }
                if (p->rc)
                {
                    p->rc->level = p->level + 1;
                    q1[++f1] = p->rc;
                }
                else
                {
                    struct node* pt =create_node();
                    if (pt != NULL)
                    {
                        pt->n = 0;
                        pt->level = p->level + 1;
                        q1[++f1] = pt;
                    }
                }
            }
        }
        int div = 1;
        int width = 128;
        int base[20];
        base[0] = width;
        r1 = -1;
        base[max_level] = width / pow(2, max_level);
        for (int i = max_level - 1; i >= 1; i--)
        {
            base[i] = base[i + 1] * 2;
        }
        int first[20] = { 0 };
        for (int i = 1; i <= max_level; i++)
        {
            for (int j = i; j <= max_level; j++)
            {
                first[i] += base[j]/2;
            }
        }
        for (int i = 1; i <= max_level; i++)
        {
            int inc = base[i - 1];
            if (i == 5)first[i] = 0;
            for (int j = 0; j < first[i]; j++)
            {
                cout << "-";
            }
            int cnt = 0;
            while (r1 != f1 && q1[r1 + 1]->level == i)
            {
                if (q1[r1 + 1]->n >= 10 && q1[r1 + 1]->n < 100)inc -= 1;
                else if (q1[r1 + 1]->n >= 1000 && q1[r1+1]->n < 10000)inc -= 2;
                else if (q1[r1 + 1]->n >= 10000)inc -= 3;
                if (i == 4 && cnt == 1)inc -= 1;
                if (i == 4 && cnt == 5)inc -= 2;
                if (i == 5 && cnt == 0)inc += 1;
                if (i == 5 && (cnt == 1 || cnt == 5 || cnt ==7  ||cnt == 13))inc -= 1;
                if (i == 5 && (cnt == 3)||(cnt == 10))inc -= 2;        
                if (i == 5 && cnt == 11)inc -= 3;
                cnt++;                
                cout << q1[++r1]->n;
                for (int k = 0; k < inc; k++)
                {
                    cout << "-";
                }
             inc = base[i - 1];
            }
            cout << endl;
        }
            cout << endl;
    }
}
void print_tree_char(struct node* t)
{
    if (t)
    {
        struct node* q1[100];
        int r1 = -1;
        int f1 = -1;
        t->level = 1;
        q1[++f1] = t;
        int max_level = get_h(t);
        while (r1 != f1)
        {
            struct node* p = q1[++r1];
            if (p->n == 0)
            {
                if (p->level == max_level)break;
                q1[++f1] = create_node();
                q1[f1]->c = '#';
                q1[f1]->level = p->level + 1;
                q1[++f1] = create_node();
                q1[f1]->c = '#';
                q1[f1]->level = p->level + 1;
            }
            else
            {
                if (p->level == max_level)break;
                if (p->lc)
                {
                    p->lc->level = p->level + 1;
                    q1[++f1] = p->lc;
                }
                else
                {
                    struct node* pt = create_node();
                    if (pt != NULL)
                    {
                        pt->c = '#';
                        pt->level = p->level + 1;
                        q1[++f1] = pt;
                    }

                }
                if (p->rc)
                {
                    p->rc->level = p->level + 1;
                    q1[++f1] = p->rc;
                }
                else
                {
                    struct node* pt = create_node();
                    if (pt != NULL)
                    {
                        pt->c = '#';
                        pt->level = p->level + 1;
                        q1[++f1] = pt;
                    }
                }
            }
        }
        int div = 1;
        int width = 128;
        int base[20];
        base[0] = width;
        r1 = -1;
        base[max_level] = width / pow(2, max_level);
        for (int i = max_level - 1; i >= 1; i--)
        {
            base[i] = base[i + 1] * 2;
        }
        int first[20] = { 0 };
        for (int i = 1; i <= max_level; i++)
        {
            for (int j = i; j <= max_level; j++)
            {
                first[i] += base[j] / 2;
            }
        }
        for (int i = 1; i <= max_level; i++)
        {
            int inc = base[i - 1];
            if (i == 5)first[i] = 0;
            for (int j = 0; j < first[i]; j++)
            {
                cout << "-";
            }
            int cnt = 0;
            while (r1 != f1 && q1[r1 + 1]->level == i)
            {
                if (i == 4 && cnt == 1)inc -= 1;
                if (i == 4 && cnt == 5)inc -= 2;
                if (i == 5 && cnt == 0)inc += 1;
                if (i == 5 && (cnt == 1 || cnt == 5 || cnt == 7 || cnt == 13))inc -= 1;
                if (i == 5 && (cnt == 3) || (cnt == 10))inc -= 2;
                if (i == 5 && cnt == 11)inc -= 3;
                cnt++;
                cout << q1[++r1]->c;
                for (int k = 0; k < inc; k++)
                {
                    cout << "-";
                }
                inc = base[i - 1];
            }
            cout << endl;
        }
        cout << endl;
    }
}
void bracket_print_char(struct node* t)
{
    if (t)
    {
        cout << t->c;
        if (t->lc)
        {                
            cout << "(";
            bracket_print_char(t->lc);        
        }
        if (t->rc)
        {
            if (!t->lc)
            {
                cout << "(";
            }
            cout << ",";
            bracket_print_char(t->rc);        
        }
        if(t->rc || t->lc)
            cout << ")";
    }
    else
    {
        return;
    }
}
void bracket_print_int(struct node* t)
{
    if (t)
    {
        cout << t->n;
        if (t->lc)
        {
            cout << "(";
            bracket_print_int(t->lc);
        }
        if (t->rc)
        {
            if (!t->lc)
            {
                cout << "(";
            }
            cout << ",";
            bracket_print_int(t->rc);
        }
        if (t->rc || t->lc)
            cout << ")";
    }
    else
    {
        return;
    }
}
struct node* insert(struct node* head, int num)
{
    if (!head)
    {
        head = create_node();
        head->n = num;
    }
    else
    {
        if (num <= head->n)
        {
            head->lc = insert(head->lc, num);
        }
        else if (num > head->n)
        {
            head->rc = insert(head->rc, num);
        }
    }
    return head;
}
int main()
{
    cout <<endl<< "-----------------------根据给出的一组数据构造二叉树-------------------------" << endl;
    cout << "数字个数：";
    int n1;
    cin >> n1;
    int num[100];
    for (int i = 0; i < n1; i++)
    {
        cin >> num[i];
    }
    struct node* head2 = NULL;
    for (int i = 0; i < n1; i++)
    {
        head2 = insert(head2, num[i]);
    }
    cout << "前序遍历：";
    pre_tra(head2);
    cout << endl;
    cout << "中序遍历：";
    in_tra(head2);
    cout << endl;
    cout << "后序遍历：";
    post_tra(head2);
    cout << endl;
    cout << "深度：" << get_h(head2) << endl;
    cout << "最大值：" << find_max(head2) << endl;
    cout << "最小值：" << find_min(head2) << endl;
    cout << "嵌套括号表示：";
    bracket_print_int(head2);
    cout << endl;
    cout << "根据输入数据构造：" << endl;
    if (get_h(head2) <= 5)
    {
        cout << "图形：（0表示没有结点）" << endl;
        print_tree_int(head2);
    }
    else
    {
        cout << "深度大于5，无法输出" << endl;
    }
    cout << "-----------------------根据前中序，中后序构造二叉树-------------------------" <<endl << endl;
    cout << "前序："; cin >> pre;
    cout << "中序："; cin >> in;
    cout << "后序："; cin >> post;
    int n = strlen(pre);
    struct node* head = build_pre_in(0, n - 1, 0, n - 1);
    struct node* head1 = build_in_post(0, n - 1, 0, n - 1);
    int h1 = get_h(head);
    int h2 = get_h(head1);

    cout << "根据前中序构造：" << endl;
    cout << "嵌套括号表示：";
    bracket_print_char(head);    
    cout << endl;
    cout << "深度：" << h2 << endl;
    if (h1 <= 5)
    {
        cout << "图形：（'#'表示没有结点）" << endl;
        print_tree_char(head);
    }
    else
    {
        cout << "深度大于5，无法打印图形" << endl;
    }
    cout << endl;
    cout << "根据中后序构造：" << endl;
    cout << "嵌套括号表示：";
    bracket_print_char(head1);
    cout << endl;    
    cout << "深度：" << h2 << endl;
    if (h1 <= 5)
    {
        cout << "图形：（'#'表示没有结点）" << endl;
        print_tree_char(head1);
    }
    else
    {
        cout << "深度大于5，无法打印图形" << endl;
    }
    return 0;
}

测试用例：

8

12 33 234 1 44 32 11 9

ABCDEF

CBDAEF

CDBFEA

结果：