Perguntas básicas da entrevista de árvore binária
- 1. Pergunta 144 do LeetCode --- Travessia da pré-encomenda da árvore binária
- 2. Pergunta LeetCode 94 --- Percurso em ordem da árvore binária
- 3. Pergunta LeetCode 145 --- travessia pós-pedido da árvore binária
- 4. Pergunta LeetCode 965 --- árvore binária de valor único
- 5. Pergunta LeetCode 104 - a profundidade máxima de uma árvore binária
- 6. LeetCode Pergunta 226 --- Inverter árvore binária
- 7. Pergunta LeetCode 100 - a mesma árvore
- 8. Pergunta LeetCode 572 --- subárvore de outra árvore
- 9. Item de oferta de dedo de espada 28 --- Árvore binária simétrica
1. Pergunta LeetCode 144-Preorder travessia da árvore binária
Link: link .
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
//因为你需要知道在开辟空间大小的时候，开辟多大才行，所以要算结点的个数
int TreeSize(struct TreeNode* root)
{
if(root == NULL)
return 0;
else
return 1+TreeSize(root->left) + TreeSize(root->right);
}
//前序遍历
void _preorderTraversal(struct TreeNode* root,int* array,int* pi)
{
if(root == NULL)
return;
array[(*pi)++] = root->val;
_preorderTraversal(root->left,array,pi); //这里的pi是传过来的指针，可以直接的使用
_preorderTraversal(root->right,array,pi);
}
//这里值得注意的就是在传i的时候一定要传地址，因为只有传值才能做到在同一个i上++的效果
int* preorderTraversal(struct TreeNode* root, int* returnSize){
int size = TreeSize(root);
int* array = (int*)malloc(sizeof(int)*size);
int i = 0;
_preorderTraversal(root,array,&i); //思考题目就明白他需要你把结点的值都放在一个数组里面
*returnSize = size;
return array;
}
2. LeetCode Questão 94 - Travessia em ordem da árvore binária
Link: link .
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int TreeSize(struct TreeNode* root)
{
if(root == NULL)
return 0;
else
return 1+TreeSize(root->left)+TreeSize(root->right);
}
//左子树 根 右子树
void _inorderTraversal(struct TreeNode* root,int* array,int* pi)
{
if(root == NULL)
return;
_inorderTraversal(root->left,array,pi);
array[(*pi)++] = root->val;
_inorderTraversal(root->right,array,pi);
}
int* inorderTraversal(struct TreeNode* root, int* returnSize){
int size = TreeSize(root);
int* array = (int*)malloc(sizeof(int)*size);
int i = 0;
_inorderTraversal(root,array,&i);
*returnSize = size;
return array;
}
3. LeetCode questão 145 - travessia pós-pedido da árvore binária
Link: link .
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int TreeSize(struct TreeNode* root)
{
if(root == NULL)
return 0;
else
return 1+TreeSize(root->left)+TreeSize(root->right);
}
void _postorderTraversal(struct TreeNode* root,int* array,int* pi)
{
if(root == NULL)
return;
_postorderTraversal(root->left,array,pi);
_postorderTraversal(root->right,array,pi);
array[(*pi)++] = root->val;
}
int* postorderTraversal(struct TreeNode* root, int* returnSize){
int size = TreeSize(root);
int* array = (int*)malloc(sizeof(int)*size);
int i = 0;
_postorderTraversal(root,array,&i);
*returnSize = size;
return array;
}
4. Pergunta LeetCode 965 - Árvore binária de valor único
Link: link .
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
//分解为当前树 和左子树 右子树的子问题然后进行递归
bool isUnivalTree(struct TreeNode* root){
if(root == NULL)
return true;
//检查当前树
if(root->left && root->val != root->left->val)
return false;
if(root->right && root->val != root->right->val)
return false;
return isUnivalTree(root->left) && isUnivalTree(root->right);
}
5. LeetCode Pergunta 104 - Profundidade máxima da árvore binária
Link: link .
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
int maxDepth(struct TreeNode* root){
if(root == NULL)
return 0;
//为的就是消除代码冗余
int leftDepth = maxDepth(root->left);
int rightDepth = maxDepth(root->right);
//求出左右子树较大的哪一个
return leftDepth > rightDepth? leftDepth+1 :rightDepth+1;
}
6. Problema LeetCode 226-Flip Binary Tree
Link: link .
Existem duas maneiras de resolver este problema: ①Vire as subárvores esquerda e direita, depois inverta as subárvores esquerda e direita da subárvore esquerda e as subárvores esquerda e direita da subárvore direita, o que é
equivalente a uma ordem do meio Travessia
//接口要求返回的是树的根结点
struct TreeNode* invertTree(struct TreeNode* root){
if(root == NULL)
{
return NULL;
}
else
{
struct TreeNode* tmp = root->left;
root->left = root->right;
root->right = tmp;
invertTree(root->left);
invertTree(root->right);
return root;
}
}
②É
equivalente à travessia de acompanhamento, a subárvore esquerda é percorrida primeiro, a subárvore direita é percorrida e a raiz é a última.
struct TreeNode* invertTree(struct TreeNode* root){
if(root == NULL)
{
return NULL;
}
else
{
struct TreeNode* right = root->right ;
root->right = invertTree(root->left);
//这里有一个覆盖值的问题，你把左边求出来直接链在了右边，那么右边原来的就没有了被覆盖了，你在转换就不对了
root->left = invertTree(right);
return root;
}
}
7. Pergunta LeetCode 100 - a mesma árvore
Link: link .
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
//把每一种情况都考虑到
bool isSameTree(struct TreeNode* p, struct TreeNode* q){
if(p == NULL && q == NULL)
return true;
//结构不同
if(p != NULL && q == NULL)
return false;
if(p == NULL && q != NULL)
return false;
//走到这里的时候就可以确定此时p和q都是不为空的，再来判断他们的值是否相同
if(p->val != q->val) //此时==并不能判断出来结果，不能说他们一开始给的两个结点相同就直接返回true
return false;
return isSameTree(p->left,q->left) && isSameTree(p->right,q->right);
}
8. LeetCode questão 572-subárvore de outra árvore
Link: ligação . Esta
questão precisa usar a interface da questão anterior, o que fará com que a solução mais fácil.
Deixe cada subárvore em t e s ser comparada, se eles são iguais, satisfaça
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
bool isSameTree(struct TreeNode* p, struct TreeNode* q);
bool isSameTree(struct TreeNode* p, struct TreeNode* q){
if(p == NULL && q == NULL)
return true;
//结构不同
if(p != NULL && q == NULL)
return false;
if(p == NULL && q != NULL)
return false;
//走到这里的时候就可以确定此时p和q都是不为空的，再来判断他们的值是否相同
if(p->val != q->val) //此时==并不能判断出来结果，不能说他们一开始给的两个结点相同就直接返回true
return false;
return isSameTree(p->left,q->left) && isSameTree(p->right,q->right);
}
//t是s完全相同的一部分（包括叶子）
//子树就是和你的一个子树相不相同
//让t和s中的每一颗子树都进行比较，如果有相同，则满足
bool isSubtree(struct TreeNode* s, struct TreeNode* t){
if(s == NULL)
return false;
if(isSameTree(s,t))
return true;
//此时我需要让我的t去和我的s中的每一结点所在的子树都去比较
return isSubtree(s->left,t) || isSubtree(s->right,t);
}
9. Item de oferta de dedo em espada 28 - Árvore binária simétrica
Link: link . Para
determinar se uma árvore é simétrica, você deve primeiro determinar se os filhos esquerdo e direito são simétricos e iguais. Você também precisa determinar se a subárvore esquerda do filho esquerdo é simétrica com a subárvore direita do filho direito , e se a subárvore direita do filho esquerdo é igual ao filho esquerdo do filho direito. A subárvore é simétrica.
bool _isSymmetric(struct TreeNode* left, struct TreeNode* right)
{
//这两种if情况判断的都是结构上面的不同
if(left == NULL && right == NULL)
return true;
if(left == NULL || right == NULL)
return false;
return left->val == right->val
&& _isSymmetric(left->left, right->right)
&& _isSymmetric(left->right, right->left);
}
bool isSymmetric(struct TreeNode* root){
if(root == NULL)
return true;
return _isSymmetric(root->left, root->right);
}
