直观打印二叉树

最新推荐文章于 2023-04-02 15:29:53 发布
最新推荐文章于 2023-04-02 15:29:53 发布
阅读量201 收藏
点赞数
原文链接：http://www.cnblogs.com/MrRS/p/9599532.html
版权

先看效果：

主要算法流程：

0.   按层遍历二叉树并确定每一个节点的相对位置和每一层的最后一个节点（在每一个节点的数据结构中增加一项pos，代表当前节点的位置）。

1.   递归获取每一棵子树的最左位置与最右位置。

2.   根据1获取的位置进行冲突调整，主要存在以下两种冲突：（设当前节点为cur，当前节点左子树最右节点为lchild_most_r，右子树最左节点为rchild_most_l）

　　0）：lchild_most_r->pos >= cur->pos

　　　　对于这种情况我的调整方法为cur及其rchild全部节点的位置向右移动lchild_most_r->pos - cur->pos + 1位置。

　　1）：rchild_most_l->pos <= cur->pos

　　　　对于这种情况将rchild全部节点向右移动cur->pos - rchild_most_l->pos位置。

　　并在移动的过程中继续递归获取每一棵子树的最左位置与最右位置进行冲突调整，最后返回整棵树的最左位置min_pos。

3.   由于树的某些节点位置可能为负，因此将整棵树的位置向右移动min_pos位置。

4.    至此每一个节点的最终（相对）位置已经确定，已经可以较直观的打印出来树的形状了，不过我又做了一些添加，也就是将节点连接起来，具体细节不在赘述，详见代码。

#include <iostream>
#include <string>
#include <queue>

using namespace std;

#define MIN(x, y)      ((x) < (y) ? (x) : (y))
#define MAX(x, y)      ((x) > (y) ? (x) : (y))
#define ALIGN(x, c);      {for(int i = 0; i<x; ++i) cout << c;}
int intlen(int _x) {
    int len = 0;
    if (_x == 0)
        return 1;
    while (_x != 0) {
        _x /= 10;
        ++len;
    }
    return len;
}
string int2str(int _x) {
    string tmp, res;
    do {
        tmp.push_back((_x % 10) + '0');
        _x /= 10;
    } while (_x != 0);
    for (size_t index = tmp.size() - 1; index != -1; --index)
        res.push_back(tmp[index]);
    return res;
}

class binaryTree {
private:
    struct node {
        int value;
        node *lchild;
        node *rchild;
        int pos;
        node(int _value = 0, int _pos = 0, node *_lchild = nullptr, node *_rchild = nullptr) :
            value(_value), lchild(_lchild), rchild(_rchild), pos(_pos) {}
    };
    struct returnData {
        int l_pos;
        int r_pos;
        returnData(int _l_most_r = INT_MAX, int _r_most_l = INT_MIN) : l_pos(_l_most_r), r_pos(_r_most_l) {}
    };
    node *src_root;
    node *res_root;
private:
    void nodesPosAdj(node *_head, int _changes) {
        if (_head == nullptr)
            return;
        if (_head->lchild)
            _head->lchild->pos += _changes;
        if (_head->rchild)
            _head->rchild->pos += _changes;
        nodesPosAdj(_head->lchild, _changes);
        nodesPosAdj(_head->rchild, _changes);
    }

    returnData binaryPosAdj(node *_root, node *_head) {
        int changes = 0;
        returnData tmp, lchild_data, rchild_data;

        if (_head == nullptr)
            return tmp;
        lchild_data = binaryPosAdj(_root, _head->lchild);
        rchild_data = binaryPosAdj(_root, _head->rchild);
        while (_head->lchild != nullptr && lchild_data.r_pos >= _head->pos) {
            changes = lchild_data.r_pos - _head->pos + 2;
            _head->pos += changes;
            _head->rchild->pos += changes;
            nodesPosAdj(_head->rchild, changes);
            if (_head != _root)
                rchild_data = binaryPosAdj(_root, _head->rchild);
        }
        while (_head->rchild != nullptr && rchild_data.l_pos <= _head->pos) {
            changes = _head->pos - rchild_data.l_pos + 2;
            _head->rchild->pos += changes;
            nodesPosAdj(_head->rchild, changes);
            //if (_head != _root)
            rchild_data = binaryPosAdj(_root, _head->rchild);
        }
        tmp.l_pos = MIN(_head->pos, lchild_data.l_pos);
        tmp.r_pos = MAX(_head->pos, rchild_data.r_pos);
        return tmp;
    }

    void binaryTreePrint_bkp(node *_root) {
#define FILLSPACE(src, nums, c);  { for(size_t index = 0; index < nums; ++index) src.push_back(c); } 
        queue<node *>src;
        node *tmp = nullptr;
        int level = 0;
        int pre_pos = 0, min_pos = 0, pre_len = 0;
        vector<int> nodes_per_level(2, 0);  //level nodes;
        string chars;

        if (_root == nullptr)
            return;
        min_pos = binaryPosAdj(_root, _root).l_pos;
        min_pos = abs(min_pos);
        _root->pos += min_pos;
        src.push(_root);
        nodes_per_level[level] = 1;
        while (!src.empty()) {
            tmp = src.front();
            src.pop();
            ALIGN(tmp->pos - pre_pos - pre_len, ' ');
            pre_pos = tmp->pos;
            pre_len = intlen(tmp->value);
            cout << tmp->value;
            if (tmp->lchild) {
                tmp->lchild->pos += min_pos;
                src.push(tmp->lchild);
                nodes_per_level[level + 1]++;
            }
            if (tmp->rchild) {
                tmp->rchild->pos += min_pos;
                src.push(tmp->rchild);
                nodes_per_level[level + 1]++;
            }

            if (--nodes_per_level[level] == 0) {
                cout << endl;
                nodes_per_level.push_back(0);
                ++level;
                pre_pos = 0;
                pre_len = 0;
            }
        }
    }

    void refreshNodesPos(int _min_pos, node *_head) {
        if (_head == nullptr)
            return;
        _head->pos += _min_pos;
        if (_head->lchild)
            refreshNodesPos(_min_pos, _head->lchild);
        if (_head->rchild)
            refreshNodesPos(_min_pos, _head->rchild);
    }
public:
    binaryTree() : src_root(nullptr), res_root(nullptr) {}
    void generateFixedBinaryTree(void) {
        queue<node *> src;
        node *tmp = nullptr;
        int x = 0, lchild = 0, rchild = 0;

        cout << "please enter root value: ";
        cin >> x;
        src.push(src_root = new node(x));
        while (!src.empty()) {
            tmp = src.front();
            src.pop();
            cout << "please enter " << tmp->value << "'s lchild and rchild: ";
            cin >> lchild >> rchild;
            if (lchild != -1)
                src.push(tmp->lchild = new node(lchild));
            if (rchild != -1)
                src.push(tmp->rchild = new node(rchild));
        }
    }

    void generateFixedBinaryTree(vector<int> _nodes) {
        node *tmp = nullptr;
        queue<node *> x;
        int index = 0;
        int min_pos = 0;

        if (_nodes[0] == '#')
            return;
        x.push(src_root = new node(_nodes[index++], 0));
        min_pos = src_root->pos;
        while (!x.empty()) {
            tmp = x.front();
            x.pop();
            if (_nodes[index] != '#') {
                x.push(tmp->lchild = new node(_nodes[index], (tmp->pos - intlen(_nodes[index]) - 1)));
                min_pos = MIN(min_pos, (tmp->pos - intlen(_nodes[index]) - 1));
            }
            ++index;
            if (_nodes[index] != '#')
                x.push(tmp->rchild = new node(_nodes[index], (tmp->pos + (intlen(tmp->value) + 1))));
            ++index;
        }
    }

    void generateRandomBinaryTree(int _maxsize, int _maxvalue) {
        node *tmp = nullptr;
        queue< node * > src;
        int nullvalue = (_maxvalue >> 1);
        int value = 0;
        int maxsize = (rand() % _maxsize);
        int size = 0;

        src_root = new node(rand() % _maxvalue);
        if (src_root->value == nullvalue)
            return;
        ++size;
        src.push(src_root);
        while ((!src.empty()) && (size < maxsize)) {
            tmp = src.front();
            src.pop();
            if (tmp->value != '#') {
                value = rand() % _maxvalue;
                if (value != nullvalue) {//((value > (nullvalue - 10)) && (value > (nullvalue + 10))) {
                    ++size;
                    src.push(tmp->lchild = new node(value));
                }
                else
                    src.push(tmp->lchild = new node('#'));
                value = rand() % _maxvalue;
                if (value != nullvalue) {//((value > (nullvalue - 10)) && (value > (nullvalue + 10))) {
                    ++size;
                    src.push(tmp->rchild = new node(value));
                }
                else
                    src.push(tmp->rchild = new node('#'));
            }
        }
    }

    void generateRandomBinaryTree(vector<int> _nodes) {
        int flag = 1;  //0: lchild    1: rchild    2: lchild&&rchild
        queue<node *> x;
        node *tmp = nullptr;
        int index = 1;

        src_root = new node(_nodes[0]);
        x.push(src_root);
        while (index < _nodes.size() && !x.empty()) {
            tmp = x.front();
            x.pop();
            flag = (rand() % 3);  //flag = 0 / 1 / 2
            if (flag == 0) {
                tmp->lchild = new node(_nodes[index++]);
                x.push(tmp->lchild);
            }
            else if (flag == 1) {
                tmp->rchild = new node(_nodes[index++]);
                x.push(tmp->rchild);
            }
            else {
                tmp->lchild = new node(_nodes[index++]);
                tmp->rchild = new node(_nodes[index++]);
                x.push(tmp->lchild);
                x.push(tmp->rchild);
            }
        }
    }

    void binaryTreePrint(void) {
        queue<node *>src;
        node *tmp = nullptr;
        int level = 0;
        int pre_num_pos = 0, pre_line_pos = 0, min_pos = 0, pre_len = 0, fill_len = 0;
        vector<int> nodes_per_level(2, 0);  //level nodes;
        vector<string> chars(1);
        vector<string> nums(1);

        if (src_root == nullptr)
            return;
        min_pos = binaryPosAdj(src_root, src_root).l_pos;
        refreshNodesPos(abs(min_pos), src_root);
        src.push(src_root);
        nodes_per_level[level] = 1;
        while (!src.empty()) {
            tmp = src.front();
            src.pop();
            fill_len = tmp->pos - pre_num_pos - pre_len;
            chars[level] += *new string((tmp->pos - pre_line_pos - pre_len), ' ');
            chars[level] += pre_len > 1 ? *new string(pre_len - 1, ' ') : "";
            chars[level] += '|';
            if (tmp->lchild) {
                nums[level] += *new string(tmp->lchild->pos - (tmp->pos - fill_len), ' ');
                nums[level] += *new string(tmp->pos - tmp->lchild->pos, '-');
            }
            else
                nums[level] += *new string(fill_len, ' ');
            nums[level] += int2str(tmp->value);
            pre_num_pos = tmp->pos;
            pre_line_pos = tmp->pos;
            pre_len = intlen(tmp->value);
            if (tmp->rchild) {
                int len = intlen(tmp->rchild->value);
                len = tmp->rchild->pos - tmp->pos - (len > 1 ? len - 1 : 0);
                nums[level] += *new string(len, '-');
                pre_num_pos += len;
            }
            if (tmp->lchild) {
                src.push(tmp->lchild);
                nodes_per_level[level + 1]++;
            }
            if (tmp->rchild) {
                src.push(tmp->rchild);
                nodes_per_level[level + 1]++;
            }
            if (--nodes_per_level[level] == 0) {
                nums[level] += '\n';
                nums.push_back("");
                chars[level] += '\n';
                chars.push_back("");
                nodes_per_level.push_back(0);
                ++level;
                pre_num_pos = 0;
                pre_line_pos = 0;
                pre_len = 0;
            }
        }

        int index_nums = 0, index_chars = 0;
        for (size_t index = 0; index < nums.size() - 1; ++index) {
            cout << nums[index_nums++];
            cout << chars[++index_chars];
        }
    }
};

int main(void)
{
    vector<int> src_nodes({             6,
                             1,                        12,
                        0,        3,          10,                13,
                    '#', '#', '#', '#',    4,     14,        20,     16,
                                         2,  5, 11, 15, '#', '#', '#', '#',
                                      '#', '#', '#', '#', '#', '#', '#', '#' });
    vector<int> src_nodes2({      2,
                        3,                   4,
                    5,       6,        3,                   5,
                '#', '#', '#', '#',  1,       2,       3,          4,
                                  '#', '#','#', '#', '#', '#','#', '#' });
    binaryTree tree;
    tree.generateFixedBinaryTree(src_nodes);
    tree.binaryTreePrint();
    cout << endl << endl;
    tree.generateFixedBinaryTree(src_nodes2);
    tree.binaryTreePrint();

    system("pause");
    return 0;
}

 

转载于:https://www.cnblogs.com/MrRS/p/9599532.html

weixin_30475039
关注
在控制台直观打印二叉树结构
陈群浩的专栏
10-28 984
在学习各种二叉树的时候，肯定会有这么个需求，怎么把树直观打印出来印证自己的想法，网上找过不少文章，很可惜没有找到我想要的效果，而且有的也不严谨，节点数据长度稍微长点就会整体变形不能看。自己写了一个能符合自己想要的效果，贡献出来给有缘来到这里的朋友。 先贴个打印效果 50 --------------------------------------- | | 30
Golang(五十四)[树-二叉树]
weixin_42366378的博客
05-19 646
Golang-树-二叉树
打印二叉树形状 画二叉树的图
09-27
/*这是一个在字符环境中，用ASCII码打印二叉树形状的算法。 采用层次遍法。 算法拙劣，仅供初学者做练习，（本人也是初学者，自学数据结构，刚好学到这二叉树这一章，搞几个二叉的例题，却不知道其构造形状，想调用图形ＡＰＩ做个美观点的，却有点偏离本章的学习目的，只好用字符打印， linux环境中打印的还可以，ＤＯＳ屏幕如果不够宽您输出到文本，如果您有更好的算法一定不吝赐教。我的ＱＱ：137241638 mail：hnflcp@139.com*/ void PBTNodePrint(PBTNode *pb[],int n,int h) { int l=-1, r=0, i,j,k, end; char c; PBTNode *p; if(n<=0||hlevel==1) { for(i=0;ispace;i++) printf(" "); printf("%c",pb[0]->data); printf("\n"); return; } h=h-pb[0]->level+2; for(k=0;k<h;k++) { j=0; l--; r++; for(i=0;ilrflag==0)?l:r; end+=p->parent->space; for(;jlrflag==0)?'/':'\\'; printf("%c",c); } printf("\n"); } for(i=0;ilrflag==0) p->space=p->parent->space+l; else p->space=p->parent->space+r; } for(i=0,j=0;i<n;i++)//打印关键字数据 { p=pb[i]; for(;jspace;j++) printf(" "); printf("%c",p->data); } printf("\n"); } //循环打印所有层的数据
直观地打印二叉树
ZCC的专栏
11-13 752
public class PrintBinaryTree { //二叉树节点的定义 public static class Node { public int value; public Node left; public Node right; public Node(int data) { this.value = data; } } //打
二叉树问题---较为直观的打印二叉树
冰殇的博客
07-31 909
class TreeNode: def __init__(self, x): self.val = x self.left = None sele.right = None def printTree(root): if not root: return print("Binary Tree: ") pr
直观的打印一颗二叉树
liang_Ri的博客
03-02 396
直观的打印一颗二叉树 在节点值两边加上特定的字符串标记来区分孩子和位置以及之间的位置关系： HXH：表示头结点 X；vYv：表示节点 Y 是左下方最近节点的孩子；Z：表示节点 Z 是左上方最近节点的孩子 遍历树的顺序为：右子树 -> 根 -> 左子树； 避免节点值长度不同影响对其，规定每个节点值长度为固定值（这里规定为 10） 最直观的打印二叉树 public class Prin...
打印二叉树结构
12-28
void printree1(binnode *subroot)//采用RVL遍历方法 { stack*> stack; int k=0,m=0,n=0,ans=0; int layer[10]; binnode* p=subroot; while(!stack.empty()||p) { if(p) { stack.push(p);...}
横向打印二叉树1
08-08
横向打印二叉树的目的是将树的结构以水平的方式展示出来，这样可以直观地看出树的层次结构。输出中，每个节点值之间用句点"."代替空格，以方便比对空格的数量。例如，样例输出的“...|-2010-|...|-5”就表示了二叉树...
PHP实现按之字形顺序打印二叉树的方法
12-20
在本场景中，我们要讨论的是“之字形”或“锯齿形”遍历，它是一种特殊的遍历方式，适用于打印二叉树的节点。 之字形遍历的规则是：从根节点开始，第一层的节点按照从左到右的顺序打印，第二层的节点按照从右到左的...
打印二叉树-按照二叉树的形状打印
11-29
打印二叉树-按照二叉树的形状打印 用C++实现，运行成功
形象直观地打印二叉树
qq_40800602的博客
02-05 235
保证节点的对称性情况下，直观打印二叉树
左神算法：如何较为直观地打印二叉树（Java版）
热门推荐
寒泉
12-13 7万+
本题来自左神《程序员代码面试指南》“如何较为直观地打印二叉树”题目。 题目 二叉树可以用常规的三种遍历结果来描述其结构，但是不够直观，尤其是二叉树中有重复值的时候，仅通过三种遍历的结果来构造二叉树的真实结构更是难上加难，有时则根本不可能。 给定一棵二叉树的头节点head，已知二叉树节点值的类型为32 位整型，请实现一个打印二叉树的函数，可以直观地展示树的形状，也便于画出真实的结构。 题解 这是一道较开放的题目，实现者不仅要设计出符合要求且不会产生歧义的打印方式，还要考虑实现难度，在面试时仅仅写出思路必然.
如何较为直观的打印二叉树
weixin_45590018的博客
10-12 115
如何较为直观的打印二叉树 package com.atguigu; import java.util.HashMap; import java.util.Scanner; import java.util.Stack; public class Main { public static StringBuilder sb = new StringBuilder(); public void printTree(Node head) { sb.append("Binary
直观打印一颗二叉树
Beat_IT的博客
06-28 1043
思路参加《程序员代码面试指南》P106。 package com.gxu.dawnlab_algorithm4; /** * 直观打印一颗二叉树 * @author junbin * * 2019年6月28日 */ public class PrintBinaryTree { public static class Node{ public int data; public...
算法：如何较为直观地打印二叉树
OceanStar的博客
06-22 989
二叉树可以用常规的三种遍历结果来描述其结构，但是不够直观，尤其是二叉树中有重复 值的时候，仅通过三种遍历的结果来构造二叉树的真实结构更是难上加难，有时则根本不可能。 给定一棵二叉树的头节点 head，已知二叉树节点值的类型为 32 位整型，请实现一个打印二叉 树的函数，可以直观地展示树的形状，也便于画出真实的结构。（1）第一步要解决的问题是用什么样的方式可以无歧义的打印二叉树，也就是设计打印的样式。这里我们是这样做的：假设有二叉树如下 打印出的样式如下：怎么看呢？（2）第二个要解决的问题：规定节点打印时占
打印二叉树
最新发布
buzhidao2333shuosha的博客
04-02 470
在终端打印二叉树
先序二叉树的图形化打印方法
打印二叉树可以用于调试程序，验证二叉树的结构是否符合预期，或者在教学中帮助理解复杂的数据结构和算法。 7. 注意事项 进行先序遍历时，需要注意处理空节点的情况，即当节点不存在（例如为null或None）时，应跳过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值