横向打印二叉树

问题描述

二叉树可以用于排序。其原理很简单：对于一个排序二叉树添加新节点时，先与根节点比较，若小则交给左子树继续处理，否则交给右子树。

当遇到空子树时，则把该节点放入那个位置。

比如，10 8 5 7 12 4 的输入顺序，应该建成二叉树如下图所示，其中.表示空白。

...|-12
10-|
...|-8-|
.......|...|-7
.......|-5-|
...........|-4

本题目要求：根据已知的数字，建立排序二叉树，并在标准输出中横向打印该二叉树。

输入格式

输入数据为一行空格分开的N个整数。 N<100，每个数字不超过10000。

输入数据中没有重复的数字。

输出格式

输出该排序二叉树的横向表示。为了便于评卷程序比对空格的数目，请把空格用句点代替：

样例输入1

10 5 20

样例输出1

...|-20
10-|
...|-5

样例输入2

5 10 20 8 4 7

样例输出2

.......|-20
..|-10-|
..|....|-8-|
..|........|-7
5-|
..|-4

---

这个题并没有做出来，首先手打了一个二叉搜索树，然后中序遍历，遍历的结果就是这个横向打印的二叉树的从下向上的值，如样例中的：

5　　10　　20　　8　　4　　7

中序遍历的结果是：

4　　5　　7　　8　　10　　20

也刚好是排序之后的结果。

在这里我还有一个问题没有解决，那就是求每个节点的深度，或是每个深度都有哪些节点。这样子的话，我们就能找到每个值在二叉树中的具体位置（只要我们把这个树看成一个网格）

但是这个二叉树的第一个指针指向的不是根节点，而是最后一个我们插入的值。最终也没能算出每个节点的深度。

---

#include<iostream>
#include<string>

using namespace std;

struct node{
    int val;
    node *lc, *rc;
}; 

// 插入 
node* insert(node *p, int x)
{
    if(p == NULL){
        node *q = new node;
        q -> val = x;
        q -> lc = q -> rc = NULL;
        return q;
    }
    else{
        if(x < p -> val) p -> lc = insert(p -> lc, x);
        else p -> rc = insert(p -> rc, x);
        return p;
    }
}

// 查找
int find(node* p, int x, int dp)
{
    if(p == NULL) return -1;
    else if(x == p -> val) return dp;
    else if(x < p -> val) return find(p -> lc, x, dp+1);
    else return find(p -> rc, x, dp+1);
 } 


 
// 删除
node* remove(node *p, int x)
{
    if(p == NULL) return NULL;
    else if(x < p -> val) p -> lc = remove(p -> lc, x);
    else if(x > p -> val) p -> rc = remove(p -> rc, x);
    else if(p -> lc == NULL){
        node *q = p -> rc;
        delete p;
        return q;
    }
    else if(p -> lc -> rc == NULL){
        node *q = p -> lc;
        q -> rc = p -> rc;
        delete p;
        return q;
    }
    else{
        node *q;
        for(q = p -> lc;q -> rc -> rc != NULL;q = q -> rc);
        node *r = q -> rc;
        q -> rc = r -> lc;
        r -> lc = p -> lc;
        r -> rc = p -> rc;
        delete p;
        return r; 
    }
    return p;
 } 

// 回忆一下整数快速幂 
int pow(int x, int n)
{
    int ret = 1;
    if(n == 0) return 1;
    while(n)
    {
        if(n&1) ret *= x;
        x *= x;
        n >>= 1;
    }
    return ret;
}

// 中序遍历 
int ret[109] = {0};
int NUM = 0;
void InOder(node *b)
{
    if(b != NULL){
        InOder(b -> lc);
        // cout<<b -> val<<endl;
        ret[++NUM] = b -> val;
        InOder(b -> rc);
    }
}

// 求节点的深度 
int find_deep(node *p, int x, int dp)
{
    // cout<<dp<<endl;
    if(p -> val == x) return dp;
    if(p != NULL)
    {
        find_deep(p -> rc, x, ++dp);
        find_deep(p -> lc, x, ++dp);
    }
}

/*-----------------------------*/
// 查找某个节点的深度 
static int depth=0;
void print_depth(node *p)
{
    depth++;
    if(!p)
        goto out;
    else{
        printf("node %d: %d
", p -> val, depth);
        print_depth(p -> rc);
        print_depth(p -> lc);
    }
    out:
           depth--;
}
/*----------------------------*/
void level_sum_out(node *p, int level){  
  
    if(!p){  
        return;  
    }  
  
    if(1==level){  
        printf("%d ",p->val);  
    }else{  
        level_sum_out(p->lc,level-1);  
        level_sum_out(p->rc,level-1);  
    }  
}  

//如何求出二叉树的高度?  
int getHeight(node *p){  
    if(NULL==p){  
        return 0;  
    }else{  
        int lh=getHeight(p->lc);  
        int rh=getHeight(p->rc);  
        return (lh>rh)?(lh+1):(rh+1);  
    }  
}  
/*----------------------------*/
int main()
{
    string s;
    // 输入没有说明长度, getline 好点 
    getline(cin, s);
    int an = 0;
    // 先记录一下根节点 
    for(int i=0;i<s.size();i++){
        if(s.at(i) == ' ') break;
        an += (int(s.at(i)) - '0') * pow(10, i);
    } 
    // cout<<"an: "<<an<<endl; 
    // 建立二叉搜索树 
    node *t = NULL;
    s = " " + s;
    // 反向迭代器可以避免考虑数的位数 
    string::reverse_iterator rite;
    int k = 0, num = 0;
    for(rite = s.rbegin();rite!=s.rend();rite++){
        if(*rite == ' '){
            // cout<<num<<endl;
            t = insert(t, num);
            k = num = 0;
            continue;
        }
        num += (int(*rite)-'0') * pow(10, k++);
    }
    // 接下来就是想办法将它打印出来 
    // 中序遍历
    InOder(t);
    for(int i=1;i<=NUM;i++)
        cout<<ret[i]<<" "; 
    cout<<'
';

    // cout<<"high"<<getHeight(t)<<endl; 
    cout<<t -> val<<endl;
    int y = find_deep(t, 4, 1);
    // int y = find(t, 5, 1);
    cout<<y<<endl;
    
    return 0;
}

 2019-02-20

08:32:26