L2-012 关于堆的判断（25 分)

最新推荐文章于 2024-04-12 10:32:39 发布

原创最新推荐文章于 2024-04-12 10:32:39 发布 · 1.1k 阅读

1 ·

CC 4.0 BY-SA版权

PAT练习题专栏收录该内容

22 篇文章

订阅专栏

本文介绍了一个程序，该程序实现了一种方法来构建小顶堆，并针对给定的元素集合进行插入操作。随后，程序能够判断特定的关系是否存在于堆中的元素间，如根节点判断、兄弟节点判断等。

L2-012 关于堆的判断（25 分)

将一系列给定数字顺序插入一个初始为空的小顶堆H[]。随后判断一系列相关命题是否为真。命题分下列几种：

x is the root：x是根结点；
x and y are siblings：x和y是兄弟结点；
x is the parent of y：x是y的父结点；
x is a child of y：x是y的一个子结点。

输入格式：

每组测试第1行包含2个正整数N（≤ 1000）和M（≤ 20），分别是插入元素的个数、以及需要判断的命题数。下一行给出区间[−10000,10000]内的N个要被插入一个初始为空的小顶堆的整数。之后M行，每行给出一个命题。题目保证命题中的结点键值都是存在的。

输出格式：

对输入的每个命题，如果其为真，则在一行中输出T，否则输出F。

输入样例：

5 4
46 23 26 24 10
24 is the root
26 and 23 are siblings
46 is the parent of 23
23 is a child of 10

输出样例：

F
T
F
T

就是手写一个二叉排序树，so easy！！

# include <iostream>
# include <cmath>
# include <cstring>
# include <string>
# include <map>
# include <algorithm>
# include <vector>
# include <cstdio>
# include <string>
# include <queue>

using namespace std;
const int maxn = 10000;


void insert(int h[], int last)
{
    int father = last / 2;
    while( father && h[father] > h[last])
    {
        swap(h[father], h[last]);
        last = father;
        father = last / 2;
    }
}

bool find(int h[], int x, int a, int b, int len)
{
    int root = x;
    queue<int> q;
    q.push(root);
    while(!q.empty())
    {
        root = q.front();
        q.pop();
        int ta = h[root * 2];
        int tb = h[root * 2 + 1];
        if(ta == a && tb == b || ta == b && tb == a)
        {
            return true;
        }
        if(root * 2 <= len && root * 2 + 1 <= len)
        {
            q.push(root * 2);
            q.push(root * 2 + 1);
        }
    }
    return false;
}

bool find_p(int h[], int x, int a, int b, int len)
{
    int root = x;
    while(h[root] != a && root <= len)
    {
        root++;
    }
    if(h[root*2] == b || h[root * 2 + 1] == b)
    {
        return true;
    }
    return false;
}


bool judge(int h[], int len, int a, int b, string str)
{
    if(str == "root")
    {
        if(a == h[1])
        {
            return true;
        }
        else
            return false;
    }
    else if(str == "siblings")
    {
        return find(h, 1, a, b, len);
    }
    else if(str == "parent")
    {
        return find_p(h, 1, a, b, len);
    }
    else
    {
         return find_p(h, 1, b, a, len);
    }
}



int main(int argc, char *argv[])
{
    int h[maxn];
    int n, m;
    cin >> n >> m;
    for(int i = 1; i <= n; i++)
    {
        cin >> h[i];
        insert(h, i);
    }

    for(int i = 0; i < m; i++)
    {
        int a , b;
        string str, link;
        cin >> a >> str;
        if(str != "and")
        {
            cin >> str >> link;//root
            if(link != "root")
            {
                cin >> str >> b;//parent child
            }
        }
        else
        {
            cin >> b >> str >> link;//siblings
        }
        bool flag = judge(h, n, a, b, link);
        if(flag)
        {
            cout <<"T" << endl;
        }
        else
        {
            cout << "F" << endl;
        }
    }

    return 0;
}