Índice
1. Árvore binária de valor único
2. Verifique se as duas árvores são iguais
4. Traversal de pré-ordem da árvore binária
5. Traversal inorder de uma árvore binária
6. Percurso pós-ordem de uma árvore binária
7. Uma subárvore de outra árvore
8. Estrutura e travessia da árvore binária
Não há nada de graça no mundo!
1. Árvore binária de valor único
Link : Lituo
Código 1 :
/**
* 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);
}Pensamentos : (1) [Se o valor de retorno do filho esquerdo é igual + se o valor de retorno do filho direito é igual] Quando o filho esquerdo não é igual à raiz ou o filho direito não é igual à raiz, o árvore não é igual [condições para retornar true Existem mais, então há menos condições para retornar desigualdade] [Código 1] (2) Percorra e compare com o valor da raiz
Nota: (1) Tente não definir variáveis estáticas e variáveis globais em questões de OJ
2. Verifique se as duas árvores são iguais
Link : Lituo
código :
/**
* 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->val != q->val)
{
return false;
}
return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}Idéias : recursão; dividir e conquistar
3. Árvore binária simétrica
Link : Lituo
código :
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
bool _isSymmetric(struct TreeNode* p, struct TreeNode* q)
{
//
if (p == NULL && q == NULL)
{
return true;
}
//其中一个为空
if (p == NULL || q == NULL)
{
return false;
}
return p->val == q->val && _isSymmetric(p->left, q->right) && _isSymmetric(p->right, q->left);
}
bool isSymmetric(struct TreeNode* root)
{
if (root == NULL)
{
return true;
}
return _isSymmetric(root->left, root->right);
}Ideia : Primeiro, julgue se a subárvore esquerda e a subárvore direita da árvore são iguais; então, julgue a subárvore esquerda da subárvore esquerda e a subárvore direita da subárvore direita, e a subárvore direita da subárvore esquerda e o filho esquerdo de a subárvore direita Se as árvores são iguais e repita a operação
4. Traversal de pré-ordem da árvore binária
Link : Lituo
código :
/**
* 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().
//意思是返回值可以被malloc，假设由调用者释放
*/
//首先确定二叉树的节点个数
int BinaryTreeSize(struct TreeNode* root)
{
return root == NULL ? 0 : (BinaryTreeSize(root->left)+BinaryTreeSize(root->right) + 1);
}
int* preorder(struct TreeNode* root, int* a, int* pi)
{
if (root == NULL)
{
return;
}
a[*pi] = root->val;
(*pi)++;
preorder(root->left, a, pi);
preorder(root->right, a, pi);
}
int* preorderTraversal(struct TreeNode* root, int* returnSize)
{
//定义的是数组的指针，因为定义的如果是数组，出了这个函数，就被销毁了
int size = BinaryTreeSize(root);//j节点个数
int* a = (int*)malloc(sizeof(int) * size);//定义数组
if (a == NULL)
{
printf("malloc fail\n");
exit(-1);
}
*returnSize = size;
//前序遍历，并把结果，给数组,
int i = 0;
preorder(root,a, &i);
return a;
}Ideia : Em primeiro lugar, podemos facilmente pensar na travessia de pré-ordem e alterar o printf da travessia de pré-ordem que aprendemos antes em uma atribuição de array. Olhando para o significado da questão, precisamos definir um ponteiro de matriz e o número de nós na árvore binária e, em seguida, chamar a função de travessia de pré-ordem o máximo possível para resolvê-la.
Nota: returnSize representa o tamanho do array, esta função é equivalente ao parâmetro de saída, returnSize, que é definido fora, mas não tem valor, e precisamos alinhá-lo para atribuição. [Um ponteiro deve ser usado aqui, porque a alteração do parâmetro formal não afeta o parâmetro real]
5. Traversal inorder de uma árvore binária
Link : Lituo
código :
/**
* 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 BinaryTreeSize(struct TreeNode* root)
{
return root == NULL ? 0 : (BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1);
}
void inorder(struct TreeNode* root, int* a, int* pi)
{
if (root == NULL)
{
return;
}
inorder(root->left, a, pi);
a[*pi] = root->val;
(*pi)++;
inorder(root->right, a, pi);
}
int* inorderTraversal(struct TreeNode* root, int* returnSize)
{
int size = BinaryTreeSize(root);
*returnSize = size;
int* a = (int*)malloc(sizeof(int) * size);
if (a == NULL)
{
printf("malloc fail\n");
exit(-1);
}
int i = 0;
inorder(root, a, &i);
return a;
}6. Percurso pós-ordem de uma árvore binária
Link : Lituo
código :
/**
* 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 BinaryTreeSize(struct TreeNode* root)
{
return root == NULL ? 0 : (BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1);
}
void postorder(struct TreeNode* root, int* a, int* pi)
{
if (root == NULL)
{
return;
}
postorder(root->left, a, pi);
postorder(root->right, a, pi);
a[*pi] = root->val;
(*pi)++;
}
int* postorderTraversal(struct TreeNode* root, int* returnSize)
{
int size = BinaryTreeSize(root);
*returnSize = size;
int* a = (int*)malloc(sizeof(int) * size);
int i = 0;
postorder(root, a, &i);
return a;
}7. Uma subárvore de outra árvore
Link : Lituo
código :
/**
* 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->val != q->val)
{
return false;
}
return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot)
{
if (root == NULL)
{
return false;
}
return isSameTree(root, subRoot) || isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
}Ideia : dividir e conquistar, se existe uma parte igual a subRoot na raiz + se existe uma parte igual a subRoot na subárvore esquerda + se existe uma parte igual a subRoot na subárvore esquerda.
Nota: Na função principal, podemos perder a instrução condicional if.Se este código não for escrito, root->left causará problemas.
8. Estrutura e travessia da árvore binária
Link : Niuke
código :
#include <stdio.h>
#include <stdlib.h>
typedef struct BinaryTreeNode
{
char data;
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
}BTNode;
//先构建一个二叉树【前序遍历】
BTNode* CreatTree(char* a, int* pi)
{
if (a[*pi] == '#')
{
(*pi)++;
return NULL;
}
//先构建根
BTNode* root = (BTNode*)malloc(sizeof(BTNode));
root->data = a[*pi];
(*pi)++;
//再构建左子树和右子树
root->left = CreatTree(a, pi);
root->right = CreatTree(a, pi);
return root;
}
void InOrder(BTNode* root)
{
if (root == NULL)
{
return;
}
InOrder(root->left);
printf("%c ", root->data);
InOrder(root->right);
}
int main()
{
char a[100];
scanf("%s", a);
int i = 0;
BTNode* tree = CreatTree(a, &i);
InOrder(tree);
free(tree);
tree = NULL;
return 0;
}Idea : A string da ideia de travessia de pré-ordem, construa uma árvore binária [ao encontrar '#', retorne NULL] e, em seguida, imprima a ideia de travessia em ordem.