【牛客网面试必刷TOP101】二叉树篇（三），2024年最新大数据开发中常见的面试题

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新大数据全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注大数据）

正文

{
    pre_left[i] = pre[i + 1];//第一个元素为根
    vin_left[i] = vin[i];
}
//右子树
int size_right = vinLen - root - 1;
int\* pre_right = (int\*)malloc(sizeof(int) \* size_right);
int\* vin_right = (int\*)malloc(sizeof(int) \* size_right);
int j = 0;//数组从0下标开始
for(int i = root + 1; i < vinLen; i++)
{
    pre_right[j] = pre[i];
    vin_right[j] = vin[i];
    j++;
}
head->left = reConstructBinaryTree(pre_left, size_left, vin_left, size_left);
head->right = reConstructBinaryTree(pre_right, size_right, vin_right, size_right);
return head;

}

---


### <2>输出二叉树的右视图


**描述**



> 
> 请根据二叉树的前序遍历，中序遍历恢复二叉树，并打印出二叉树的右视图  
>  数据范围：0 ≤ n ≤ 10000  
>  要求： 空间复杂度O(n)，时间复杂度O(n)
> 
> 
> 


如输入[1,2,4,5,3],[4,2,5,1,3]时，通过前序遍历的结果[1,2,4,5,3]和中序遍历的结果[4,2,5,1,3]可重建出以下二叉树：  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/bc0579fe9655487e9b236a7d4461d949.png#pic_center)  
 所以对应的输出为[1,3,5]。


**示例1**



> 
> 输入：[1,2,4,5,3],[4,2,5,1,3]  
>  返回值：[1,3,5]  
>  备注：  
>  二叉树每个节点的值在区间[1,10000]内，且保证每个节点的值互不相同。
> 
> 
> 


**思路分析：**


#### 重建二叉树 + 层序遍历


第一步是重建二叉树，跟上一题一样，重建二叉树完成了以后就是把每一层的最后一个节点找到。这里就可以用层序遍历，而怎么知道每一层的最后一个元素是什么呢？  
 层序遍历用的是队列，我们计算队列的大小就知道每一层有多少个节点，然后每pop一个节点就`size--`，当size减到0时就是一层的最后一个元素。

typedef struct TreeNode* QDateType;

typedef struct QueueNode
{
struct QueueNode* next;
QDateType date;
}QueueNode;

typedef struct Queue
{
QueueNode* head;
QueueNode* tail;
}Queue;

bool QueueEmpty(Queue* pst);

void QueueInit(Queue* pst)
{
pst->head = pst->tail = NULL;
}

void QueueDestroy(Queue* pst)
{
QueueNode* cur = pst->head;
while (cur)
{
QueueNode* next = cur->next;
free(cur);
cur = next;
}
pst->head = pst->tail = NULL;

}

void QueuePush(Queue* pst, QDateType x)
{
QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
if (newnode == NULL)
{
printf(“malloc fail\n”);
exit(-1);
}
newnode->date = x;
newnode->next = NULL;
if (pst->head == NULL)
{
pst->head = newnode;
pst->tail = newnode;
}
else
{
pst->tail->next = newnode;
pst->tail = newnode;
}
}

void QueuePop(Queue* pst)
{
if (pst->head->next == NULL)
{
free(pst->head);
pst->head = pst->tail = NULL;
}
else
{
QueueNode* next = pst->head->next;
free(pst->head);
pst->head = next;
}
}

QDateType QueueBack(Queue* pst)
{
return pst->tail->date;
}

QDateType QueueFront(Queue* pst)
{
return pst->head->date;
}

//真返回非0
bool QueueEmpty(Queue* pst)
{
return pst->head == NULL;
}

int QueueSize(Queue* pst)
{
QueueNode* cur = pst->head;
int size = 0;
while (cur)
{
size++;
cur = cur->next;
}
return size;
}

struct TreeNode* BuyNode(int x)
{
struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode*));
root->val = x;
root->left = NULL;
root->right = NULL;
return root;
}

struct TreeNode* reConstructBinaryTree(int* pre, int preLen, int* vin, int vinLen ) {
//判空
if(vinLen == 0)
{
return NULL;
}
//第一个节点为根
struct TreeNode* head = BuyNode(pre[0]);
//通过中序遍历找根
int root = 0;
for(int i = 0; i < vinLen; i++)
{
if(pre[0] == vin[i])
{
root = i;
break;
}
}
//左子树
int size_left = root;
int* pre_left = (int*)malloc(sizeof(int) * size_left);
int* vin_left = (int*)malloc(sizeof(int) * size_left);
for(int i = 0; i < size_left; i++)
{
pre_left[i] = pre[i + 1];//第一个元素为根
vin_left[i] = vin[i];
}
//右子树
int size_right = vinLen - root - 1;
int* pre_right = (int*)malloc(sizeof(int) * size_right);
int* vin_right = (int*)malloc(sizeof(int) * size_right);
int j = 0;//数组从0下标开始
for(int i = root + 1; i < vinLen; i++)
{
pre_right[j] = pre[i];
vin_right[j] = vin[i];
j++;
}
head->left = reConstructBinaryTree(pre_left, size_left, vin_left, size_left);
head->right = reConstructBinaryTree(pre_right, size_right, vin_right, size_right);
return head;
}

int* solve(int* xianxu, int xianxuLen, int* zhongxu, int zhongxuLen, int* returnSize ) {
struct TreeNode* root = reConstructBinaryTree(xianxu, xianxuLen, zhongxu, zhongxuLen);
Queue q;
QueuePush(&q, root);
//记录返回数组
int* tmp = (int*)malloc(sizeof(int) * 10000);
int i = 0;
while(!QueueEmpty(&q))
{
int size = QueueSize(&q);
while(size–)
{
struct TreeNode* ret = QueueFront(&q);
QueuePop(&q);
if(size == 0)
{
tmp[i++] = ret->val;
}
//入左子树
if(ret->left)
{
QueuePush(&q, ret->left);
}
//入右子树
if(ret->right)
{
QueuePush(&q, ret->right);
}
}
}
*returnSize = i;
return tmp;
}

---


## 三、小结



> 
> 我们可以看到二叉树基本解题思路就是递归，如果递归想不出代码，可以直接看最后一步怎么实现，其次一定要多画图理解。
> 
> 
> 


点击链接[一起刷题吧]( )




---



**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）**
![img](https://img-blog.csdnimg.cn/img_convert/85c1f7188b1ccc36957a5ed410052f53.png)

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

画图理解。
> 
> 
> 


点击链接[一起刷题吧]( )




---



**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）**
[外链图片转存中...(img-K2RTC50i-1713361585891)]

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**