Inhaltsverzeichnis
2. Überprüfen Sie, ob die beiden Bäume gleich sind
4. Durchqueren des Binärbaums vorbestellen
5. Inorder-Traversierung eines Binärbaums
6. Durchlaufen eines Binärbaums nach der Bestellung
7. Ein Teilbaum eines anderen Baums
8. Struktur und Durchquerung des Binärbaums
Es gibt nichts umsonst auf der Welt!
1. Einwertiger Binärbaum
Link : Lituo
Code 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);
}Gedanken : (1) [Ob der Rückgabewert des linken Kindes gleich ist + ob der Rückgabewert des rechten Kindes gleich ist] Wenn das linke Kind nicht gleich der Wurzel ist oder das rechte Kind nicht gleich der Wurzel ist, ist das Baum ist nicht gleich [Bedingungen für die Rückgabe von true Es gibt mehr, daher gibt es weniger Bedingungen für die Rückgabe von Ungleichheit] [Code 1] (2) Durchlaufen und Vergleich mit dem Wert der Wurzel
Hinweis: (1) Versuchen Sie, in OJ-Fragen keine statischen Variablen und globalen Variablen zu definieren
2. Überprüfen Sie, ob die beiden Bäume gleich sind
Link : Lituo
Code :
/**
* 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);
}Ideen : Rekursion; Teile und herrsche
3. Symmetrischer Binärbaum
Link : Lituo
Code :
/**
* 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);
}Idee : Beurteilen Sie zunächst, ob der linke Teilbaum und der rechte Teilbaum des Baums gleich sind. Beurteilen Sie dann den linken Teilbaum des linken Teilbaums und den rechten Teilbaum des rechten Teilbaums sowie den rechten Teilbaum des linken Teilbaums und das linke Kind von der rechte Teilbaum Ob die Bäume gleich sind, und wiederholen Sie den Vorgang
4. Durchqueren des Binärbaums vorbestellen
Link : Lituo
Code :
/**
* 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;
}Idee : Zunächst können wir uns leicht die Durchquerung vor der Bestellung vorstellen und den Ausdruck der Durchquerung vor der Bestellung, den wir zuvor gelernt haben, in eine Array-Zuweisung ändern. Wenn wir uns die Bedeutung der Frage ansehen, müssen wir einen Array-Zeiger und die Anzahl der Knoten im Binärbaum definieren und dann die Funktion der Vorbestellungsdurchquerung so weit wie möglich aufrufen, um sie zu lösen.
Hinweis: returnSize stellt die Größe des Arrays dar. Diese Funktion entspricht dem Ausgabeparameter returnSize, der außerhalb definiert ist, aber keinen Wert hat, und wir müssen ihn für die Zuweisung ausrichten. [Hier sollte ein Zeiger verwendet werden, da die Änderung des formalen Parameters keinen Einfluss auf den tatsächlichen Parameter hat]
5. Inorder-Traversierung eines Binärbaums
Link : Lituo
Code :
/**
* 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. Durchlaufen eines Binärbaums nach der Bestellung
Link : Lituo
Code :
/**
* 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. Ein Teilbaum eines anderen Baums
Link : Lituo
Code :
/**
* 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);
}Idee : Teilen und erobern, ob es einen Teil gleich subRoot in der Wurzel gibt + ob es einen Teil gleich subRoot im linken Teilbaum gibt + ob es einen Teil gleich subRoot im linken Teilbaum gibt.
Hinweis: In der Hauptfunktion fehlt möglicherweise die if-Bedingungsanweisung. Wenn dieser Code nicht geschrieben wird, führt root->left zu Problemen.
8. Struktur und Durchquerung des Binärbaums
Link : Niuke
Code :
#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;
}Idee : Die Zeichenfolge der Idee der Durchquerung vor der Bestellung, einen Binärbaum erstellen [bei Begegnung mit „#“ NULL zurückgeben] und dann die Idee der Durchquerung in der Reihenfolge ausdrucken.