关于堆的判断

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

  1. x is the root:x是根结点;
  2. x and y are siblings:x和y是兄弟结点;
  3. x is the parent of y:x是y的父结点;
  4. 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
#include <cstdio>
#include <vector>
#include <cstring>
using namespace std;
vector<int> v;
int n;
void upAdjust(int i) 
{
    if(i == 1) 
    {
  	return ;
    }
    while(i != 1) 
    {
        if(v[i] < v[i / 2]) 
  	{
            swap(v[i], v[i / 2]);
            i = i / 2;
        } 
    	else 
  	{
            break;
        }
    }
}
void judge1(int a) 
{
    if(v[1] == a) 
    {
  	printf("T\n");
    }
    else 
    {
  	printf("F\n");
    }
}
void judge2(int a, int b) 
{
    int indexa = 0, indexb = 0;
    for(int i = 1; i <= n; i++) 
    {
        if(v[i] == a) 
  	{
   	    indexa = i;
  	}
        if(v[i] == b) 
  	{
   	    indexb = i;
  	}
    }
    if(indexa > indexb) 
    {
  	swap(indexa, indexb);
    }
    if(indexa % 2 == 0 && indexb - indexa == 1) 
    {
  	printf("T\n");
    }
    else 
    {
  	printf("F\n");
    }
}
void judge3(int a, int b) 
{
    int indexa = 0, indexb = 0;
    for(int i = 1; i <= n; i++) 
    {
        if(v[i] == a) 
  	{
   	    indexa = i;
  	}
        if(v[i] == b) 
  	{
   	    indexb = i;
  	}
    }
    if((2 * indexa) == indexb || (2 * indexa) + 1 == indexb) 
    {
  	printf("T\n");
    }
    else 
    {
  	printf("F\n");
    }
}
void judge4(int a, int b) 
{
    int indexa = 0, indexb = 0;
    for(int i = 1; i <= n; i++) 
    {
        if(v[i] == a) 
  	{
   	    indexa = i;
  	}
        if(v[i] == b) 
  	{
   	    indexb = i;
  	}
    }
    if(indexa == indexb * 2 || indexa == 2 * indexb + 1)
    {
  	printf("T\n");
    } 
    else 
    {
  	printf("F\n");
    }
}
int main() 
{
    int k, a, b;
    char c[100];
    scanf("%d%d", &n, &k);
    v.resize(n + 1);
    for(int i = 1; i <= n; i++) 
    {
        scanf("%d", &v[i]);
        upAdjust(i);
    }
    for(int i = 0; i < k; i++) 
    {
        scanf("%d%s", &a, c);
        if(strcmp(c, "and") == 0) 
  	{
            scanf("%d%s%s", &b, c, c);
            judge2(a, b);
        } 
    	else 
  	{
            scanf("%s", c);
            if(strcmp(c, "a") == 0) 
   	    {
                scanf("%s%s%d", c, c, &b);
                judge4(a, b);
            } 
   	    else 
   	    {
                scanf("%s", c);
                if(strcmp(c, "root") == 0) 
    		{
                    judge1(a);
                } 
    		else 
    		{
                    scanf("%s%d", c, &b);
                    judge3(a, b);
                }
            }
        }
    }
    return 0;
}
### 关于数据结构的PTA平台练习题解析 #### 的概念及其性质 是一种特殊的完全二叉树,分为最大和最小两种形式。在最大中,任意节点的关键字都不大于其父节点的关键字;而在最小中,则相反[^1]。 #### PTA平台上的典型相关题目分析 以下是几个可能出现在PTA平台上的与相关的经典判断题或练习题: 1. **关于的操作** 插入新元素时,需将其放置到底并逐步上滤至合适位置以保持特性[^2]。 2. **建过程中的时间复杂度** 使用自下而上的调整方法建立一个含有n个节点的最大的时间复杂度为O(n)[^3]。这是因为虽然单次调整操作可能是O(log n),但由于底层节点数量较多且移动距离较短,整体复杂度可以优化到线性级别。 3. **删除根节点后的处理方式** 当从中移除顶部元素后,通常会把最后一个叶子节点移到顶端再进行下沉调整直到满足新的条件为止[^4]。 ```python def heapify(arr, n, i): largest = i l = 2 * i + 1 r = 2 * i + 2 if l < n and arr[i] < arr[l]: largest = l if r < n and arr[largest] < arr[r]: largest = r if largest != i: arr[i],arr[largest] = arr[largest],arr[i] heapify(arr, n, largest) def buildHeap(arr,n): startIdx = int((n/2)) - 1 for pos in range(startIdx , -1 ,-1): heapify(arr,n,pos ) ``` 上述代码展示了如何通过`heapify`函数来维护数组表示下的二叉结构,并提供了构建初始的方法。 ####
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

【执珪】瑕瑜·夕环玦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值