2019-1-2

最新推荐文章于 2020-05-20 19:21:33 发布
最新推荐文章于 2020-05-20 19:21:33 发布
阅读量161 收藏 1
点赞数 1
分类专栏： # 机试真题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34686440/article/details/104727632
版权

三叉树

题目描述
Time Limit: 1000 ms
Memory Limit: 256 mb
一个关于三叉树的题目，小于100的值代表树叶，大于100的值为分支点，
建树的过程是水平方向建树，

输入格式：

先输入n，代表有n组数据，接下来n行，输入4个数，
第一个数代表根节点，
接下来分别代表三个子节点，-1代表子节点不存在，输入的顺序按照层次遍历的次序。
接下来，要求寻找叶子节点的最短路径，最短路径是指不经过重复的边。
输入方式，首先输入一个值m，代表m行，接下来m行输入m个叶子节点和对应的优先级，要求按优先级输出从上次到达的位置到该节点的最短路径，每条路径的最后一个节点要求输出目标叶子节点，最后要求回到根节点。

输入样例#

10
100 101 108 107
101 1 102 2
108 103 104 105
107 17 109 18
102 3 4 5
103 7 8 9
104 10 106 11
105 15 16 -1
109 19 20 21
106 12 13 14
5
8 1
14 3
16 2
5 0
19 4

输出样例#:

100 101 102 5
102 101 100 108 103 8
103 108 105 16
105 108 104 106 14
106 104 108 100 107 109 19
109 107 100
  • 关键点：
    *** 使用sort函数对数据预处理
    *** 根据给定的条件建树
    *** 根据给定的值，寻找在树中的位置
    *** 寻找公共祖先节点（带有父指针）
    1.方案一、寻找第一个相交的点（层数高的先走几步，直至层数相同，然后判断每走一步是否有公共的祖先节点）
    2.方案二、利用后序遍历求解公共祖先节点
    *** 先序遍历输出路径
#include<stdio.h>
#include<stdlib.h>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;

int input[100][4];

struct prior
{
    int id;
    int pri;
}ssd[100];
int n,m;

bool cmp(prior a,prior b)
{
    if(a.pri < b.pri) return true;
    else return false;
}

typedef struct node
{
    int id;
    int layer;//用于寻找公共祖先节点
    node* parent;
    node* lchild;
    node* mchild;
    node* rchild;
}Node,*Tree;

Node* newNode(int id)
{
    Node* temp = (Node*)malloc(sizeof(Node));
    temp->id = id;
    temp->layer = 0;
    temp->parent = temp->lchild = temp->mchild = temp->rchild = NULL;
    return temp;
}

/*
递归建树：
初始状态  层数和父节点已经建立
*/
void createTree(Node* root)
{
    int i;
    for(i = 0;i<n;i++)
    {
        if(root->id == input[i][0])
            break;
    }
    if(i == n)
        return ;

    if(input[i][1]!=-1)
    {
        Node* temp1 = newNode(input[i][1]);
        temp1->layer = root->layer + 1;

        root->lchild = temp1;
        temp1->parent = root;

        createTree(temp1);
    }
    if(input[i][2] != -1)
    {
        Node* temp2 = newNode(input[i][2]);
        temp2->layer = root->layer + 1;

        temp2->parent = root;
        root->mchild = temp2;

        createTree(temp2);
    }
    if(input[i][3]!=-1)
    {
        Node* temp3 = newNode(input[i][3]);
        temp3->layer = root->layer + 1;

        temp3->parent = root;
        root->rchild = temp3;

        createTree(temp3);
    }
}

void preOrder(Node* root)
{
    if(root)
    {
        if(root->id == input[0][0])
            printf("%d %d\n",root->id,root->layer);
        else
            printf("%d %d %d\n",root->id,root->layer,root->parent->id);
        preOrder(root->lchild);
        preOrder(root->mchild);
        preOrder(root->rchild);
    }
}

void layerOrder(Node* root)
{
    queue<Node*> q;
    q.push(root);

    while(!q.empty())
    {
        Node* qhead = q.front();
        if(qhead->id == input[0][0])
            printf("%d %d\n",qhead->id,qhead->layer);
        else
            printf("%d %d %d\n",qhead->id,qhead->layer,qhead->parent->id);

        if(qhead->lchild)
            q.push(qhead->lchild);
        if(qhead->mchild)
            q.push(qhead->mchild);
        if(qhead->rchild)
            q.push(qhead->rchild);

        q.pop();
    }
}


vector<Node*> tempPath,ansPath;
/*
实际问题：给定的孩子节点，肯定能够找到
*/

//******
Node* findChildPosition(Node* root,int childId)//有返回值的情况下只需要找到一条路径即可返回，一般情况下题目中只有一条路径
{
    if(root == NULL)
        return NULL;

    if(root->id == childId)
        return root;//找到了，或者到达终点没找到

    /*
    Node* temp = findChildPosition(root->lchild,childId);
    if(temp!= NULL)//通过左子树找到
        return temp;
    else
        temp = findChildPosition(root->mchild,childId);
    if(temp != NULL)//通过中子树找到
        return temp;
    else
        temp = findChildPosition(root->rchild,childId);
    if(temp!=NULL)//通过右子树找到
        return temp;
    else//通过所有的子树均找不到
        return NULL;
    */
    Node *tmp1,*tmp2,*tmp3;
	tmp1 = findChildPosition(root->lchild,childId);
	if(tmp1)
		return tmp1;
	tmp2 = findChildPosition(root->mchild,childId);
	if(tmp2)
		return tmp2;
	tmp3 = findChildPosition(root->rchild,childId);
	if(tmp3)
		return tmp3;

    return NULL;//通过左子树，中子树，右子树均为找到孩子节点

/*
下面的这种写法值得自己仔细的思考
以前的认识是错误的，哈哈哈哈非常的开心啊
思考：下面的这种方法就本题而言，打印路径是绝对没有问题的，但是在返回ChildId的位置的时候发生错误
tempPath.push_back()和tempPath.pop_back()的位置，是输出多有能够到达指定终点的路径
就本题而言，只有一条路径所以只会打印一条；
但是作为返回值：下面这种写法是错误的，因为在某一条子节点找到之后并不会这个节点的位置
而是继续寻找，这样的话就丢失了这个位置。返回值就是错误的。
*/
    /*
    Node* temp = NULL;
    if(root->id == childId)
    {
        tempPath.push_back(root);
        for(int i = 0;i<tempPath.size();i++)
        {
            if(i == tempPath.size()-1)
                printf("%d\n",tempPath[i]->id);
            else
                printf("%d ",tempPath[i]->id);
        }
        tempPath.pop_back();
        return root;
    }

    if(root->lchild == NULL && root->mchild == NULL && root->rchild == NULL)
        return NULL;

    tempPath.push_back(root);//首先将当前节点加入tempPath
    if(root->lchild)//访问其相邻的子节点
    {
        temp = findAndPrintChild(root->lchild,childId);
    }
    if(root->mchild)
    {
        temp = findAndPrintChild(root->mchild,childId);
    }
    if(root->rchild)
    {
        temp = findAndPrintChild(root->rchild,childId);
    }
    tempPath.pop_back();//到达这一步说明通过root的子节点到达不了目的节点，将root节点删除
    return temp;
    */
}


Node* findSameAncient(Node *root,int id1,int id2)
{
    Node *temp1,*temp2;
    int layer1,layer2;

    temp1 = findChildPosition(root,id1);
    temp2 = findChildPosition(root,id2);
    layer1 = temp1->layer;
    layer2 = temp2->layer;

    if(layer1 > layer2)
    {
        int c = layer1 - layer2;
        while(c--)
        {
            temp1 = temp1->parent;
        }
    }

    if(layer1<layer2)
    {
        int d = layer2 - layer1;
        while(d--)
        {
            temp2 = temp2->parent;
        }
    }

    if(temp1 == temp2) return temp1;

    while(temp1->parent->id != temp2->parent->id)
    {
        temp1 = temp1->parent;
        temp2 = temp2->parent;
    }

    return temp1->parent;
}


Node* prePrint(Node* root,int id)//树中只存在一条路径，不需要寻找所有的路径
{
    if(root == NULL) return NULL;
    if(root->id == id)
    {
        tempPath.push_back(root);
        for(int i = 0;i<tempPath.size();i++)
        {
            if(i == tempPath.size()-1)
                printf("%d\n",tempPath[i]->id);
            else
                printf("%d ",tempPath[i]->id);
        }
        tempPath.pop_back();

        return root;
    }

    tempPath.push_back(root);
    Node* tempNode = prePrint(root->lchild,id);
    tempPath.pop_back();
    if(tempNode)
        return tempNode;

    tempPath.push_back(root);
    tempNode = prePrint(root->mchild,id);
    tempPath.pop_back();
    if(tempNode)
        return tempNode;

    tempPath.push_back(root);
    tempNode = prePrint(root->rchild,id);
    tempPath.pop_back();
    if(tempNode)
        return tempNode;

    return NULL;//表示通过三个子节点之后没有找到，返回NULL
}

void print_out(Node* root)
{
    prePrint(root,ssd[0].id);

    Node *child1,*sameParent,*child2;
    for(int i = 0;i<m-1;i++)
    {
        child1 = findChildPosition(root,ssd[i].id);
        child2 = findChildPosition(root,ssd[i+1].id);
        sameParent = findSameAncient(root,ssd[i].id,ssd[i+1].id);
        while(child1->parent!=sameParent)
        {
            printf("%d ",child1->parent->id);
            child1 = child1->parent;
        }
        prePrint(sameParent,ssd[i+1].id);
    }

    child1 = findChildPosition(root,ssd[m-1].id);
    while(child1->parent!=sameParent)
    {
        printf("%d ",child1->parent->id);
        child1 = child1->parent;
    }
    printf("%d\n",root->id);

}

int main()
{
    /*
    数据输入
    */
    int i;

    scanf("%d",&n);
    for(i = 0;i<n;i++)
    {
        scanf("%d%d%d%d",&input[i][0],&input[i][1],&input[i][2],&input[i][3]);
    }
    scanf("%d",&m);
    for(i = 0;i<m;i++)
    {
        scanf("%d%d",&ssd[i].id,&ssd[i].pri);
    }

    /*
    初始化变量
    */

    /*
    数据处理
    */

    //建树
    Node* root = newNode(input[0][0]);
    root->layer = 1;
    root->parent = NULL;
    createTree(root);

    sort(ssd,ssd + m,cmp);
    print_out(root);

    return 0;
}
/*
IN:
10
100 101 108 107
101 1 102 2
108 103 104 105
107 17 109 18
102 3 4 5
103 7 8 9
104 10 106 11
105 15 16 -1
109 19 20 21
106 12 13 14
5
8 1
14 3
16 2
5 0
19 4
OUT:
100 101 102 5
102 101 100 108 103 8
103 108 105 16
105 108 104 106 14
106 104 108 100 107 109 19
109 107 100
*/


#include<stdio.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
using namespace std;

int n;
int input[100][4];
int m;
struct data
{
    int id;
    int priority;
}pri[100];

bool cmp(data a,data b)
{
    if(a.priority<b.priority) return true;
    else return false;
}

typedef struct node
{
    int id;
    int layer;
    node* parent;
    node* lchild;
    node* mchild;
    node* rchild;
}Node,*Tree;

Node* newNode(int id)
{
    Node* temp = (Node*)malloc(sizeof(Node));
    temp->id = id;
    temp->layer = 0;
    temp->parent = temp->lchild = temp->mchild = temp->rchild = NULL;
    return temp;
}
void createTree(Node* root)
{
    int i;
    for(i = 0;i<n;i++)
    {
        if(root->id == input[i][0])
            break;
    }
    if(i == n) return ;

    if(input[i][1] != -1)
    {
        Node* temp1 = newNode(input[i][1]);
        temp1->layer = root->layer + 1;
        temp1->parent = root;
        root->lchild = temp1;
        createTree(temp1);
    }
    if(input[i][2] != -1)
    {
        Node* temp2 = newNode(input[i][2]);
        temp2->layer = root->layer + 1;
        temp2->parent = root;
        root->mchild = temp2;
        createTree(temp2);
    }
    if(input[i][3] != -1)
    {
        Node* temp3 = newNode(input[i][3]);
        temp3->layer = root->layer + 1;
        temp3->parent = root;
        root->rchild = temp3;
        createTree(temp3);
    }
}

void preOrder(Node* root)
{
    if(root)
    {
        printf("%d\n",root->id);
        preOrder(root->lchild);
        preOrder(root->mchild);
        preOrder(root->rchild);
    }
}

Node* findChildPosition(Node* root,int id)
{
    if(root == NULL || root->id == id) return root;

    Node* temp = findChildPosition(root->lchild,id);
    if(temp) return temp;

    temp = findChildPosition(root->mchild,id);
    if(temp) return temp;

    temp = findChildPosition(root->rchild,id);
    if(temp) return temp;

    return NULL;
}

Node* leastCommonAncient(Node* root,Node* temp1,Node* temp2)
{
    int layer1 = temp1->layer;
    int layer2 = temp2->layer;
    if(layer1>layer2)
    {
        int t  = layer1 - layer2;
        while(t--)
        {
            temp1 = temp1->parent;
        }
    }
    if(layer1<layer2)
    {
        int t = layer2 - layer1;
        while(t--)
        {
            temp2 = temp2->parent;
        }
    }
    if(temp1 == temp2)
        return temp1;

    while(temp1->parent != temp2->parent)
    {
        temp1 = temp1->parent;
        temp2 = temp2->parent;
    }
    return temp1->parent;
}

vector<Node*> up,down;
void printUp(Node* high,Node* low)//high<-low
{
    printf("%d ",low->id);
    low = low->parent;
    while(low!=high)
    {
        printf("%d ",low->id);
        low = low->parent;
    }
    printf("%d",high->id);
}

void printDown(Node* high,Node* low)//high->low
{
    vector<Node*> path;
    path.push_back(low);
    low = low->parent;
    while(low != high)
    {
        path.push_back(low);
        low = low->parent;
    }
    //path.push_back(high);

    for(int i = path.size()-1;i>=0;i--)
    {
        if(i == 0)
        {
            printf("%d",path[i]->id);
        }
        else
        {
            printf("%d ",path[i]->id);
        }
    }
}

void printPath(Node* root)
{
    Node* child = findChildPosition(root,pri[0].id);
    //最开始
    printf("%d ",root->id);
    printDown(root,child);
    printf("\n");

    //中间
    for(int i = 0;i<m-1;i++)
    {
        Node* child1 = findChildPosition(root,pri[i].id);
        Node* child2 = findChildPosition(root,pri[i+1].id);
        Node* ancient = leastCommonAncient(root,child1,child2);
        printUp(ancient,child1->parent);
        printf(" ");
        printDown(ancient,child2);
        printf("\n");
    }

    //最后返回
    child = findChildPosition(root,pri[m-1].id)->parent;
    printUp(root,child);
    printf("\n");
}
int main()
{
    freopen("2019_2_2.txt","r",stdin);
    scanf("%d",&n);
    for(int i = 0;i<n;i++)
    {
        scanf("%d%d%d%d",&input[i][0],&input[i][1],&input[i][2],&input[i][3]);
    }
    scanf("%d",&m);
    for(int i = 0;i<m;i++)
    {
        scanf("%d%d",&pri[i].id,&pri[i].priority);
    }
    sort(pri,pri + m,cmp);

    Node* root = newNode(input[0][0]);
    root->layer = 1;
    createTree(root);
    printPath(root);

    return 0;
}
北枫凉
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
三叉树 北航机试题
owlmo的博客
03-08 564
一、题目描述 一个关于三叉树的题目，小于100的值代表树叶，大于100的值为分支点，建树的过程是水平方向建树。 输入格式： 先输入n，代表有n组数据，接下来n行，输入4个数，第一个数代表根节点，接下来分别代表三个子节点，-1代表子节点不存在，输入的顺序按照层次遍历的次序。接下来，要求寻找叶子节点的最短路径，最短路径是指不经过重复的边。输入方式，首先输入一个值m，代表m行，接下来m行输入m个叶子节点和对应的优先级，要求按优先级输出从上次到达的位置到该节点的最短路径，每条路径的最后一个节点要求输出目标叶子
2019-北京航天航空大学--991《数据结构与C语言程序设计》-考试大纲.docx
10-08
2019-北京航天航空大学--991《数据结构与C语言程序设计》-考试大纲
2019北航计算机考研面试流程介绍及复习的侧重点
sinat_38425013的博客
03-24 3535
2019北航计算机考研复试流程，3月17号体检，3月18号，复试报到，交csp认证报告，上机c语言考试。3月19号，3月20号，按分组进行面试，（如果你第一天面试可以少一些焦虑的时间并且第二天可以去旅游景点转转了，如果是第二天可以根据第一天面试的人的经验多准备一天），3月20号晚上8点出左右出拟录取名单，3月21日，3月22日交导师志愿表。（院内调剂大概在3.28号去签署协议）。接下来给大家分享一...
如何从树叶层开始建树三？
xuexiaodong2009的专栏
10-30 1464
如何从树叶层开始建树，如何从树叶层开始建树？中的方法虽好，可对树的要求太严格，如何从树叶层开始建树二？中的方法虽然使用各种情况，但毕竟递归了很多次，性能会差很多。 例如如下一棵树，要把叶节点是偶数的节点组成一棵树 也就是得到如下一棵树：       于是自己也在思索能不能把如何从树叶层开始建树？中的方法进行扩展，使她可以使用所有情况，最总实现了，但必须知道每一个节点所在的层次。
北航2019机试题题目描述全解析以及参考代码
sinat_38425013的博客
03-21 4846
大家好，我是2019年北航考研的考生，在3月18号参加了北航的机考，特此在这个 根据自己的回忆给出题目描述，一个测试用例，样例输出，以及本人编写的参考代码，以及思路讲解。如果我可以得到题目的原本描述，会更新给大家的。 还有做几点说明，北航上机考试建议使用标准c编程，解释一下标准c编程，不能使用基于特定平台的库，例如windows.h，linux系统下的特定库，某个厂家自己开发出的库，这些都是编译...
7-Series-XPE-2019-1-2
最新发布
06-10
7_Series_XPE_2019_1_2
cve-2019-2725修复相关的补丁p29694149_10360190115_Generic.zip
06-03
1. 首先，确保阅读并理解README.txt文件中的安装指南，这将指导用户正确地进行更新。 2. 其次，检查当前系统环境，确认是否满足补丁的安装条件。 3. 使用提供的工具或命令行指令来应用patch-catalog_26654.xml中列出...
sudo-cve-2019-18634:CVE-2019-18634的概念证明
03-21
2. **审查sudo配置**：检查sudoers文件，确保没有不必要的权限赋予非特权用户。 3. **限制环境变量**：尽可能限制sudo命令可以访问的环境变量，避免使用`env_reset`和`secure_path`选项。 4. **监控系统活动**：设置...
OpenSSH 存在输入验证错误漏洞(CVE-2019-16905)修复补丁及命令
01-15
1. `openssh-8.4p1.tar.gz`: 这是OpenSSH的源代码包，版本为8.4p1，包含修复了CVE-2019-16905漏洞的补丁。用户需要解压并编译这个源代码以安装更新后的OpenSSH服务器和客户端。 2. `openssl-1.1.1g.tar.gz`: ...
2019北航考研机试题解
我在浪里
03-25 3133
第一场第一题： #include<bits/stdc++.h> #define MAX 150005 #define MOD 1000000007 typedef long long LL; //const int INF = 1e9+7; #define VM 1000010 using namespace std; #define inf 0.00000001 //2...
北航2019机试第二题
weixin_43192836的博客
03-11 424
题目描述： 一个关于三叉树的题目，小于100的值代表树叶，大于100的值为分支点，建树的过程是水平方向建树。 输入格式： 先输入n，代表有n组数据，接下来n行，输入4个数，第一个数代表根节点，接下来分别代表三个子节点，-1代表子节点不存在，输入的顺序按照层次遍历的次序。接下来，要求寻找叶子节点的最短路径，最短路径是指不经过重复的边。输入方式，首先输入一个值m，代表m行，接下来m行输入m个叶子节点和...
2019北航机考第二题题目描述解析以及参考代码（紧接第一题）
sinat_38425013的博客
03-23 2175
题目描述：一个关于三叉树的题目，小于100的值代表树叶，大于100的值为分支点，建树的过程是水平方向建树，输入格式： 先输入n，代表有n组数据，接下来n行，输入4个数，第一个数代表根节点，接下来分别代表三个子节点，-1代表子节点不存在，输入的顺序按照层次遍历的次序。接下来，要求寻找叶子节点的最短路径，最短路径是指不经过重复的边。输入方式，首先输入一个值m，代表m行，接下来m行输入m个叶子节点和对...
苏州大学2009年复试上机真题
独住小楼听雨
03-05 224
题目描述: 文件中按文本方式存放了一段其他文章，其中有若干长度小于15的十进制或八进制数字，数字之间用“,”分开，数字内部存在且仅存在空格。八进制数以起始位“0”作为标示与十进制数区分。顺序读取这些数字将他们转变为十进制数后按从大到小的顺序排序后，输出到文件上，每个数字一行。 输入描述: _235_,34__2,_043_1_,1_3 （_代表空格） 输出描述: 342 0431 235 13...
笨办法学 Python · 续 练习 23：三叉搜索树
热门推荐
龙哥盟
08-10 3万+
练习 23：三叉搜索树 原文：Exercise 23: Ternary Search Trees 译者：飞龙 协议：CC BY-NC-SA 4.0 自豪地采用谷歌翻译 我们将研究的最终数据结构称为三叉搜索树（TSTree），它可以在一组字符串中的快速查找字符串。它类似于BSTree，但是它有三个子节点，而不是两个，每个子节点只是一个字符而不是整个字符串。在BSTre
北航计算机机试2012
xiaoxiaowanzio的博客
03-08 198
1.分解整数 某些整数能分解成若干个连续整数的和的形式，例如 15 = 1 + 2＋3＋4＋5　 15 = 4 + 5 + 6 15 = 7 + 8 某些整数不能分解为连续整数的和，例如：16 输入：一个整数N（N &amp;amp;lt;= 10000） 输出：整数N对应的所有分解组合，按照每个分解中的最小整数从小到大输出，每个分解占一行，每个数字之间有一个空格（每行最后保留一个空格）；如果没有任何分解组合，则...
2019北航机试
qq_36614721的博客
05-20 1258
代码均为自做 题目一 给定闭区间[a,b] ,要求输出 素数的等差序列,三个以上才算是序列 例如 [100,200] 会输出 151 157 163 和167 173 179 输入[1,100] 会有两个等差序列，3 5 7 和47 53 59。输出样式行末的空格保留。 #include <iostream> #include <cstdlib> #include <cmath> #include <vector> using namespace std
北航机器学习期末考试试题2019年秋
sinat_38425013的博客
12-24 7613
拥抱开源，拥抱共享，很希望能够为共享做出点贡献。以北航的机器学习期末考试为例，去csdn下载个往年试题要20，40积分实在是过分。所以在这里给出今年机器学习期末考试试题题目，以回忆为主，所以题目的描述不是很规范，总体题目在问什么还是可以知道的。我下载的往年的题目毕竟是别人的，粘到这里就不太合适了，所以就不放在这里了。题目一共100分，前6个题每个题10分，后三个每个题20，三选二。 1，贝叶斯决...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值