32. 排序二叉树

description

排序二叉树是指左子树的所有节点的值均小于它根节点的值，右子树的所有节点的值均大于它根节点的值。

输入：输入有一行，表示若干个要排序的数，输入0时停止

输出：
二叉树的凹入表示
和二叉树的中序遍历序列

sample：
input:
56 78 34 89 12 35 67 77 22 57 0

output:
        12
            22
    34
        35
56
            57
        67
            77
    78
        89

12 22 34 35 56 57 67 77 78 89

	测试输入	期待的输出	时间限制	内存限制	额外进程
测试用例 1	以文本方式显示 42 168 35 101 270 125 79 259 263 165 6 246 182 62 192 296 243 28 37 0 ↵	以文本方式显示         6↵             28↵     35↵         37↵ 42↵                 62↵             79↵         101↵             125↵                 165↵     168↵                     182↵                         192↵                             243↵                 246↵             259↵                 263↵         270↵             296↵ ↵  6 28 35 37 42 62 79 101 125 165 168 182 192 243 246 259 263 270 296↵	无限制	64M	0
测试用例 2	以文本方式显示 147 106 291 130 71 51 7 202 94 249 132 24 85 0 ↵	以文本方式显示                 7↵                     24↵             51↵         71↵                 85↵             94↵     106↵         130↵             132↵ 147↵         202↵             249↵     291↵ ↵  7 24 51 71 85 94 106 130 132 147 202 249 291↵	无限制	64M	0

code

1. 并没有难以理解的地方，按着正常的思路来写就行，注意其中空格的位置就好，我是按照教材中的代码写的
2. 代码

#include <cstdbool>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>

using namespace std;

typedef struct node
{
    int data;
    struct node *lt, *rt;
} bstnode, *bstree;

//相等 equal
bool EQ(int& a, int& b)
{
    if(a == b)
        return true;
    return false;
}

//小 less than
bool LT(int& a, int& b)
{
    if(a < b)
        return true;
    return false;
}

// 二叉树递归查找算法
bstree SearchBST(bstree t, int key)
{
    //如果成功，返回该指针，否则返回空
    if(!t || EQ(key, t->data))
        return t;
    else {
        if(LT(key, t->data))  //比根节点小，进入左子树
            return (SearchBST(t->lt, key));
        else  //进入右子树
            return (SearchBST(t->rt, key));
    }
}

//二叉树非递归查找算法
bstree SearchBST(bstree t, int key, bstnode*& father)
{
    // father是p的双亲
    bstnode* p = t;
    father = NULL;  //根节点的双亲为空
    while(p && !EQ(key, p->data)) {  //如果值相等的话那么找到了
        father = p;
        if(LT(key, p->data))
            p = p->lt;
        else
            p = p->rt;
    }
    return p;  //如果p不为空那么p的data就是查找到的值
}

/*
插入算法：
1. 为空，建立生成根节点
2. 执行查找算法，找出被插入节点的双亲节点p
3. 判断被插入节点是p的左孩子还是右孩子，然后进行插入
*/
bool InserBST(bstree& t, int key)
{
    bstnode *s, *p, *f = NULL;
    p = SearchBST(t, key, f);
    if(p != NULL)  // key已经存在，无需插入
        return false;
    s = new bstnode;
    s->data = key;
    s->lt = s->rt = NULL;

    if(f == NULL)  //插入节点为根节点
        t = s;
    else if(LT(key, f->data))
        f->lt = s;
    else
        f->rt = s;

    return true;  //插入成功
}

//先序遍历
void preorder(bstree t)
{
    if(t) {
        cout << " " << t->data;
        preorder(t->lt);
        preorder(t->rt);
    }
}

//中序遍历
void inorder(bstree t)
{
    if(t) {
        inorder(t->lt);
        cout << " " << t->data;
        inorder(t->rt);
    }
}

//凹入式
void formatprint(int key, int depth)
{
    for(int i = 0; i < 4 * depth; i++)
        cout << " ";
    cout << key << endl;
}

void listprint(bstree t, int depth)
{
    if(t) {
        listprint(t->lt, depth + 1);
        formatprint(t->data, depth);
        listprint(t->rt, depth + 1);
    }
}

int main()
{
    bstree t = NULL;  //声明二叉排序数

    // freopen("file.txt", "r", stdin);
    int tmp = 0;
    while(true) {
        cin >> tmp;
        if(!tmp)
            break;
        InserBST(t, tmp);
    }

    listprint(t, 0);
    cout << endl;
    inorder(t);
    cout << endl;

    return 0;
}

/*
56 78 34 89 12 35 67 77 22 57 0

        12
            22
    34
        35
56
            57
        67
            77
    78
        89

 12 22 34 35 56 57 67 77 78 89
*/