18.11.13 二叉树三则

二叉树的深度（10分）

题目内容：

给定一棵二叉树，求该二叉树的深度

二叉树深度定义：从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的节点个数为树的深度

输入格式:

第一行是一个整数n，表示二叉树的结点个数。二叉树结点编号从1到n，根结点为1，n <= 10

接下来有n行，依次对应二叉树的n个节点。

每行有两个整数，分别表示该节点的左儿子和右儿子的节点编号。如果第一个（第二个）数为-1则表示没有左（右）儿子

输出格式：

输出一个整型数，表示树的深度

输入样例：

3
2 3
-1 -1
-1 -1

输出样例：

2

#include <iostream>
#include <string.h>
#include <algorithm>
#include <stack>
#include <string>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <fstream>
#include <set>
#define  inf 999999;

using namespace std;
int n;
struct treenode {
    int left, right;
    treenode() {
        left = -1, right = -1;
    }
}tree[11];

int depth(int i)
{
    if (i == -1)return 0;
    int left, right;
    left = depth(tree[i].left);
    right = depth(tree[i].right);
    return max(left, right)+1;
}
int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        int x, y;
        scanf("%d%d", &x, &y);
        tree[i].left = x, tree[i].right = y;
    }
    printf("%d
", depth(1));
    return 0;
}

物质分解记录（10分）

题目内容：

对 物质分解记录 的结构进行统计分析。
例如：
给出一份 物质分解记录。
Material_1
{
Material_2
{
Material_3
                Material_4
Material_5
                {
                Material_6
                Material_7
                }
                Material_8
}
Material_9
Material_10
}
Material_11
{
Material_l3
Material_7
Material_2
{
Material_3
                Material_4
Material_5
                {
             Material_6
             Material_7
                }
                Material_8
}
Material_13
}

上述记录的含义是，Material_1分解为 Material_2、Material_9和Material_10，Material_2又分解为Material_3、Material_4、Material_5和Material_8。以此类推，大括号外书写特定物质名称，括号内表示此特定物质分解出来的子物质名称，每个子物质还可再分解。

现输入一个物质名称R，要求输出所有和物质R在记录中属于同一层次且位置在R之后的物质名称。
比如R=“Material_1” ，则应该输出“Material_11”；
比如R=“Material_9” ，则应该输出“Material_10”
如果R在代码中出现了多次，则以其第一次出现为准，即仅输出与第一次出现的R属于同一层次且位置在R之后的语句内容。
比如R=“Material_2” ，则应该输出
        Material_9
Material_10

 

 

输入格式:

输入包含多组数据。第一行是物质分解记录的份数，仅用一个整数表示。从第二行开始，每组数据包括 物质分解记录 和 所需查找的物质R 两部分，物质分解记录样式如描述中所示，R的内容和物质分解记录之间有一行空行，下一份记录与上一个R之间有两行空行。
若输入！则表示输入结束。
为简单起见，物质分解记录中每一行的内容为“{”或者“}”或者一个物质名称，不会有其他情况（比如空行）出现。同时每行文字前不会有任何缩进。物质名称是英文字母、数字和下划线组成的字符串。

 

输出格式：

对每组数据输出一行，如果R在记录中找到，则输出所有与R在同一层次且位置在R之后的物质名称，名称之间无需添加空格，紧密连接即可；否则输出No。若R是其所在层次中最后一个物质，则输出"",即输出一个空字符。

 

输入样例：

3
Material_1
{
Material_2
{
Material_3
Material_4
Material_5
{
Material_6
Material_7
}
Material_8
}
Material_9
Material_10
}

Material_2


Material_1
{
Material_2
{
Material_3
Material_4
Material_5
{
Material_6
Material_7
}
Material_8
}
Material_9
Material_10
}
Material_11
{
Material_3
Material_7
Material_2
{
Material_3
Material_4
Material_5
{
Material_6
Material_7
}
Material_8
}
Material_13
}

Material_2


Material_1
{
Material_2
{
Material_3
Material_4
Material_5
{
Material_6
Material_7
}
Material_8
}
Material_9
Material_10
}

Material_20


！

 

输出样例：

Material_9Material_10
Material_9Material_10
No

提示：

读入数据时，需采用如下方式进行读取。
例：若要读取一行输入内容，则
cin.getline(line, lineSize, ' ');
sscanf(line, "%s", tmp);

其中line和tmp为数组指针，类型为char* ，linesize为line所指向的数组的规模，为int型。
所需读取的内容最终是存储在tmp数组中。之后如需对读取的内容进行操作，就对tmp进行操作即可，读到空行时tmp长度即为0。

采用其他方法读取可能会出现WA以及RE，TLE。

#include <iostream>
#include <string.h>
#include <algorithm>
#include <stack>
#include <string>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <fstream>
#include <set>
#define  inf 999999;

using namespace std;
int n;
struct treenode {
    char value[30];
    int lay;
    treenode *parent, *right,*child;
    treenode() {
        lay = 0;
        parent = NULL, right = NULL,child=NULL;
    }
    treenode(char*val) {
        int i;
        for (i = 0; val[i]; i++)
            value[i] = val[i];
        value[i] = 0;
        lay = 0;
        parent = NULL, right = NULL, child = NULL;
    }
    void setchild(treenode*x) {
        child = x;
    }
    void setparent(treenode*x){
        parent = x;
    }
    void setright(treenode*x) {
        right = x;
    }
};

bool printbro(treenode*rt, char*val) {
    if (rt == NULL)return false;
    if (strcmp(rt->value, val) == 0)
    {
        rt = rt->right;
        while (rt) {
            printf("%s", rt->value);
            rt = rt->right;
        }
        printf("
");
        return true;
    }
    bool now = printbro(rt->child, val);
    if (now)return true;
    return printbro(rt->right, val);
}

void init() {
    scanf("%d",&n);
    cin.ignore();
    while (n--) {
        char line[30], tmp[30];
        cin.getline(line, sizeof(line), '
');
        sscanf(line, "%s", tmp);
        treenode*rt=new treenode(tmp);
        treenode*now = rt;
        int layer = 0;
        while (1)
        {
            char line[30] = { 0 }, tmp[30] = { 0 };
            cin.getline(line, 30, '
');
            sscanf(line, "%s", tmp);
            if (strlen(tmp) == 0)break;
            if (tmp[0] == '{')
                layer++;
            else if (tmp[0] == '}')layer--;
            else {
                treenode*thenode=new treenode(tmp);
                if (now->lay == layer) {
                    now->setright(thenode);
                    thenode->setparent(now->parent);
                }
                else if (now->lay > layer) {
                    while (now->lay > layer)
                        now = now->parent;
                    now->setright(thenode);
                    thenode->setparent(now->parent);
                }
                else if (now->lay < layer) {
                    now->setchild(thenode);
                    thenode->setparent(now);
                }
                now = thenode;
                now->lay = layer;
            }
        }
        cin.getline(line, sizeof(line), '
');
        sscanf(line, "%s", tmp);
        cin.getline(line, sizeof(line), '
');
        cin.getline(line, sizeof(line), '
');
        if(!printbro(rt,tmp))
            printf("No
");
    }
    char line[30];
    cin.getline(line, sizeof(line), '
');
}

int main()
{
    init();
    return 0;
}

二叉搜索树的层次遍历（10分）

题目内容：

二叉搜索树在动态查表中有特别的用处，一个无序序列可以通过构造一棵二叉搜索树变成一个有序序列，

构造树的过程即为对无序序列进行排序的过程。每次插入的新的结点都是二叉搜索树上新的叶子结点，在进行

插入操作时，不必移动其它结点，只需改动某个结点的指针，由空变为非空即可。

     这里，我们想探究二叉树的建立和层次输出。

输入格式:

只有一行，包含若干个数字，中间用空格隔开。（数字可能会有重复，对于重复的数字，只计入一个）

输出格式：

输出一行，对输入数字建立二叉搜索树后进行按层次周游的结果。

输入样例：

51 45 59 86 45 4 15 76 60 20 61 77 62 30 2 37 13 82 19 74 2 79 79 97 33 90 11 7 29 14 50 1 96 59 91 39 34 6 72 7

输出样例：

51 45 59 4 50 86 2 15 76 97 1 13 20 60 77 90 11 14 19 30 61 82 96 7 29 37 62 79 91 6 33 39 74 34 72

提示：

输入输出的最后都不带空格和回车换行

#include <iostream>
#include <string.h>
#include <algorithm>
#include <stack>
#include <string>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <fstream>
#include <set>
#define  inf 999999;

using namespace std;
int n;
struct treenode {
    int val;
    treenode *left, *right;
    treenode() {
        val = -1, left= NULL,right = NULL;
    }
    treenode(int n) {
        val = n, left = NULL, right = NULL;
    }
}*rt;

void build(treenode*root, int val) {
    if (root->val == val)return;
    if (val > root->val) {
        if (root->right)
            build(root->right, val);
        else
            root->right = new treenode(val);
    }
    else if (val < root->val) {
        if (root->left)
            build(root->left, val);
        else
            root->left = new treenode(val);
    }
}

void print() {
    queue<treenode*>all;
    printf("%d", rt->val);
    if(rt->left)
        all.push(rt->left);
    if (rt->right)
        all.push(rt->right);
    while (!all.empty()) {
        treenode*now = all.front(); all.pop();
        printf(" %d", now->val);
        if (now->left)
            all.push(now->left);
        if (now->right)
            all.push(now->right);
    }
}

void init() {
    int i=0,x;
    cin >> x;
    rt=new treenode(x);
    while (cin>>x) {
        build(rt, x);
    }
    print();
}

int main()
{
    init();
    return 0;
}

数据应该都不是很强，有点怀疑到底做对没有

好几天都忘发了，今天补上