L3-016 二叉搜索树的结构

按要求判断树的信息,考查对字符串的处理~

#include<bits/stdc++.h>
using namespace std;
const int maxn=1014;
struct node {
    int data;
    node * left;
    node * right;
};
void insert (node * &root,int v) {
    if (root==NULL) {
        root=new node;
        root->data=v;
        root->left=NULL;
        root->right=NULL;
        return;
    }
    if (v<root->data) insert (root->left,v);
    else insert (root->right,v);
}
int isFull=1,maxdepth=-1;
unordered_map<int,int> bro,l,r,father,depth,pos;
void bfs (node * root) {
    queue<node *> q;
    q.push(root);
    depth[root->data]=0;
    //maxdepth=max (depth[root->data],maxdepth);
    while (!q.empty()) {
        node * now=q.front();
        q.pop();
        //if (!now->left||!now->right) isFull=0;
        if ((!now->left&&now->right)||(now->left&&!now->right)) isFull=0;
        if (now->left&&now->right) {
            bro[now->left->data]=now->right->data;
            bro[now->right->data]=now->left->data;
        }
        if (now->left) {
            q.push(now->left);
            depth[now->left->data]=depth[now->data]+1;
            //maxdepth=max (depth[now->left->data],maxdepth);
            l[now->data]=now->left->data;
            father[now->left->data]=now->data;
        }
        if (now->right) {
            q.push(now->right);
            depth[now->right->data]=depth[now->data]+1;
            r[now->data]=now->right->data;
            father[now->right->data]=now->data;
            //maxdepth=max (depth[now->right->data],maxdepth);
        }
    }
}
int main () {
    int N,x;
    scanf ("%d",&N);
    node * root=NULL;
    for (int i=0;i<N;i++) {
        scanf ("%d",&x);
        insert (root,x);
        pos[x]=1;
    }
    bfs (root);
    //if (N<pow(2,maxdepth)-1) isFull=0;
    int q;
    scanf ("%d",&q);
    string s;
    getchar ();
    for (int i=0;i<q;i++) {
        getline (cin,s);
        //cout<<s.substr(s.length()-1-4,4)<<endl;
        if (s.substr(s.length()-4,4)=="root") {
            int rootnum=0;
            for (int j=0;j<s.length();j++) {
                if (s[j]>=‘0‘&&s[j]<=‘9‘) rootnum=rootnum*10+s[j]-‘0‘;
                else break;
            }
            if (root->data==rootnum) printf ("Yes\n");
            else printf ("No\n");
        }
        else if (s.substr(s.length()-8,8)=="siblings") {
            int num[2]={0},cnt=0;
            for (int j=0;j<s.length();j++) {
                if (s[j]>=‘0‘&&s[j]<=‘9‘) num[cnt]=num[cnt]*10+s[j]-‘0‘;
                else if (s[j-1]>=‘0‘&&s[j-1]<=‘9‘) cnt++;
            }
            if (pos[num[0]]==0||pos[num[1]]==0) printf ("No\n");
            else if (bro[num[0]]==num[1]) printf ("Yes\n");
            else printf ("No\n");
        }
        else if (s.substr(s.length()-4,4)=="tree") {
            if (isFull==1) printf ("Yes\n");
            else printf ("No\n");
        }
        else if (s.substr(s.length()-5,5)=="level") {
            int num[2]={0},cnt=0;
            for (int j=0;j<s.length();j++) {
                if (s[j]>=‘0‘&&s[j]<=‘9‘) num[cnt]=num[cnt]*10+s[j]-‘0‘;
                else if (s[j-1]>=‘0‘&&s[j-1]<=‘9‘) cnt++;
            }
            if (pos[num[0]]==0||pos[num[1]]==0) printf ("No\n");
            else if (depth[num[0]]==depth[num[1]]) printf ("Yes\n");
            else printf ("No\n");
        }
        else if (s.find("left")!=string::npos) {
            int num[2]={0},cnt=0;
            for (int j=0;j<s.length();j++) {
                if (s[j]>=‘0‘&&s[j]<=‘9‘) num[cnt]=num[cnt]*10+s[j]-‘0‘;
                else if (s[j-1]>=‘0‘&&s[j-1]<=‘9‘) cnt++;
            }
            if (pos[num[0]]==0||pos[num[1]]==0) printf ("No\n");
            else if (l[num[1]]==num[0]) printf ("Yes\n");
            else printf ("No\n");
        }
        else if (s.find("right")!=string::npos) {
            int num[2]={0},cnt=0;
            for (int j=0;j<s.length();j++) {
                if (s[j]>=‘0‘&&s[j]<=‘9‘) num[cnt]=num[cnt]*10+s[j]-‘0‘;
                else if (s[j-1]>=‘0‘&&s[j-1]<=‘9‘) cnt++;
            }
            if (pos[num[0]]==0||pos[num[1]]==0) printf ("No\n");
            else if (r[num[1]]==num[0]) printf ("Yes\n");
            else printf ("No\n");
        }
        else if (s.find("parent")!=string::npos) {
            int num[2]={0},cnt=0;
            for (int j=0;j<s.length();j++) {
                if (s[j]>=‘0‘&&s[j]<=‘9‘) num[cnt]=num[cnt]*10+s[j]-‘0‘;
                else if (s[j-1]>=‘0‘&&s[j-1]<=‘9‘) cnt++;
            }
            /*if (pos[num[0]]==0||pos[num[1]]==0) printf ("No\n");
            else*/ if (father[num[1]]==num[0]) printf ("Yes\n");
            else printf ("No\n");
        }
    }
    return 0;
}

原文地址:https://www.cnblogs.com/zhanglichen/p/12301720.html

时间: 2024-08-04 05:57:14

L3-016 二叉搜索树的结构的相关文章

PTA 7-2 二叉搜索树的结构(26 分)

这道题 错在了 交错树样例 , 少了4 分 ,谁知道什么原因的可以告诉我,感激不尽 7-2 二叉搜索树的结构(30 分) 二叉搜索树或者是一棵空树,或者是具有下列性质的二叉树: 若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值:若它的右子树不空,则右子树上所有结点的值均大于它的根结点的值:它的左.右子树也分别为二叉搜索树.(摘自百度百科) 给定一系列互不相等的整数,将它们顺次插入一棵初始为空的二叉搜索树,然后对结果树的结构进行描述.你需要能判断给定的描述是否正确.例如将{ 2 4 1

PAT L3-016 二叉搜索树的结构

https://pintia.cn/problem-sets/994805046380707840/problems/994805047903240192 二叉搜索树或者是一棵空树,或者是具有下列性质的二叉树: 若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值:若它的右子树不空,则右子树上所有结点的值均大于它的根结点的值:它的左.右子树也分别为二叉搜索树.(摘自百度百科) 给定一系列互不相等的整数,将它们顺次插入一棵初始为空的二叉搜索树,然后对结果树的结构进行描述.你需要能判断给定的

二叉搜索树(Binary Search Tree)

1.什么是二叉搜索树 二叉搜索树(Binary Search Tree)是一棵有序的二叉树,所以我们也可以称它为二叉排序树(不知道二叉树的童鞋,先看看二叉树:传送门).具有以下性质的二叉树我们称之为二叉搜索树:若它的左子树不为空,那么左子树上的所有值均小于它的根节点:若它的右子树不为空,那么右子树上所有值均大于它的根节点.它的左子树和右子树分别也为二叉搜索树. 2.二叉搜索树的结构 二叉搜索树能够高效的进行一下操作:①插入一个数值②查询是否包含某个数值③删除某个数值 根据实现的不同,还可以实现其

二叉搜索树JAVA实现

引入: 二叉搜索树是这样的一种二叉树: (1)每个元素都有一个关键值,并且没有任意两个元素有相同的关键值 (2)根节点的左子树中任意元素的关键值小于根节点的关键值. (3)根节点的右子树中任意元素的关键值大于根节点的关键值. (4)根节点的左右子树也是二叉搜索树. 我们这里就用程序来实现这样一颗二叉搜索树. 分析: 从定义看出,二叉搜索树是一种特殊的二叉树,它给每个元素加上了序的概念,但又不同于最大最小堆,它总是 左<根<右的.我们分别看常用的几个操作. 查找: 关键值查找很简单,就是从根元素

每日刷题191130 --基础知识篇 二叉搜索树

休息了两天,状态恢复了一下,补充点基础知识. 二叉搜索树 搜索树数据结构支持许多动态集合操作,包括Search,minimum,maximum,predecessor(前驱),successor(后继),INSERT和DELETE等.因此我们使用一颗搜索树既可以作为一个字典又可以作为一个优先队列.且二叉搜索树上的基本操作所花费的时间与这棵树的高度成正比.二叉搜索树有两个很重要的变体,红黑树与B树,这个我们之后有机会再补一篇文章. 顾名思义,一棵二叉搜索树是以一棵二叉树来组织的.如图所示,这样的一

数据结构(三):非线性逻辑结构-特殊的二叉树结构:堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树

在上一篇数据结构的博文<数据结构(三):非线性逻辑结构-二叉树>中已经对二叉树的概念.遍历等基本的概念和操作进行了介绍.本篇博文主要介绍几个特殊的二叉树,堆.哈夫曼树.二叉搜索树.平衡二叉搜索树.红黑树.线索二叉树,它们在解决实际问题中有着非常重要的应用.本文主要从概念和一些基本操作上进行分类和总结. 一.概念总揽 (1) 堆 堆(heap order)是一种特殊的表,如果将它看做是一颗完全二叉树的层次序列,那么它具有如下的性质:每个节点的值都不大于其孩子的值,或每个节点的值都不小于其孩子的值

【数据结构】树与树的表示、二叉树存储结构及其遍历、二叉搜索树、平衡二叉树、堆、哈夫曼树与哈夫曼编码、集合及其运算

1.树与树的表示 什么是树? 客观世界中许多事物存在层次关系 人类社会家谱 社会组织结构 图书信息管理 分层次组织在管理上具有更高的效率! 数据管理的基本操作之一:查找(根据某个给定关键字K,从集合R 中找出关键字与K 相同的记录).一个自然的问题就是,如何实现有效率的查找? 静态查找:集合中记录是固定的,没有插入和删除操作,只有查找 动态查找:集合中记录是动态变化的,除查找,还可能发生插入和删除 静态查找--方法一:顺序查找(时间复杂度O(n)) int SequentialSearch(St

ACM-数据结构-二叉搜索树(C++实现)

近日研习<计算机算法>,一点点弄明白了二叉搜索树. /* @header BSTree @abstract BSTree @discussion Insert,delete,search and order @author WalterBright,2016 */ #include <iostream> using namespace std; template <class Type> class BSTree; //模板类作为友元类需提前声明 template &l

用JS实现二叉搜索树

二叉树的节点最多只能有两个子节点,一个左侧子节点,一个右侧子节点. 二叉搜索树(BST),是二叉树的一种,但只允许在左侧节点存储比父节点小的值,在右侧节点存储比父节点大或等于父节点的值. 1.创建BST 1.1创建BST类 首先申明BST类的基本结构 function BinarySearchTree() { var Node = function(key){ this.key = key; this.left = null; this.right = null; }; var root = n