*二叉树练习题（C语言数据结构）

初级练习题：

单值二叉树：

. - 力扣（LeetCode）

思路：

主要思路：

        递归遍历

        当root->left-> != NULL  ,root->val != root->left->val返回false

        当root->right != NULL ,root->val != root->right->val返回false

        

代码如下：

bool isUnivalTree(struct TreeNode* root) 
{
    if(root == NULL)
    return true;
    if(root->left != NULL && root->val != root->left->val)
    return false;
    if(root->right != NULL&&root->val != root->right->val)
    return false;
    return  isUnivalTree(root->left)&&isUnivalTree(root->right);
}

检查两棵树是否相同：

. - 力扣（LeetCode）

思路：

主要思路：

        递归遍历

        同时递归两个二叉树。

        当两个树最后都递归到为空时，返回true。

        当一个数为空，另一个数不为空，则返回false。    

        当root1>val != root2->val返回false

        递归每个树的左子树和右子树。

代码如下：

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);
}

是否为对称二叉树：

. - 力扣（LeetCode）

思路：

        还是可以看作两棵树比较，从根节点分成两棵树，分别比较左子树根和右子树根的数值。

之后再让左右子树的叶子分别为根。

代码如下：

 bool isSymetric_(struct TreeNode* root1,struct TreeNode* root2)
 {
    if(root1 == NULL&&root2 == NULL)
    return true;
    if(root1 == NULL || root2 == NULL)
    return false;
    if(root1->val != root2->val)
    return false;
    return isSymetric_(root1->left,root2->right)&&isSymetric_(root1->right,root2->left);
 }
bool isSymmetric(struct TreeNode* root) 
{
    if(root == NULL)
    return true;
    return isSymetric_(root->left,root->right);    
}

*二叉树的前序遍历：

. - 力扣（LeetCode）

思路：

         创建一个数组，为了存放二叉树前序遍历后的值。（这里不用担心内存泄漏的问题，后台会自己释放。）

         创建时为了保证空间不浪费，这里需要一个函数提前计算一下二叉树结点的大小。

        （计算二叉树节点的函数不做详细介绍喽）。

        这里的参数int *returnSize，指的是下标，这里为什么要传参数的地址，由于在递归调用时，

返回的时候局部变量要返回，不会进行累加，如果传的不是指针，那么就会出错。

代码如下：

 int CalNums(struct TreeNode* root)
 {
    if(root == NULL)
    return 0;
    return CalNums(root->left)+CalNums(root->right)+1;
 }
 int * preorderTraversal_(struct TreeNode* root, int* returnSize,int *a)
 {
    if(root == NULL)
    return NULL;
    a[(*returnSize)++] = root->val;
    preorderTraversal_(root->left, returnSize,a);
    preorderTraversal_(root->right,returnSize,a);
    return a;
 }
int* preorderTraversal(struct TreeNode* root, int* returnSize) {
    int n = CalNums(root);
    int *arr = (int *)malloc(n*sizeof(int));
    if(arr == NULL)
    {
        perror("malloc:error");
        return NULL;
    }
    *returnSize = 0;
    return preorderTraversal_(root,returnSize,arr);
}

另一棵树的子树：

. - 力扣（LeetCode）

思路：

        可以分成两层遍历，一层是root的遍历，可以把它的每个节点都能当作一棵树的根。

        另一层遍历是，两颗树的比较的遍历，也就是每个节点都必须相等。

代码如下：

bool isSameTree(struct TreeNode* root, struct TreeNode* subRoot)
{
    if(root == NULL&& subRoot == NULL)
    return true;
    if(root == NULL || subRoot == NULL)
    return false;
    if(root->val != subRoot->val)
    return false;
    return isSameTree(root->left,subRoot->left)&&isSameTree(root->right, subRoot->right);
}
bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot)
{
    if(root == NULL)
    return false;
    if(isSameTree(root,subRoot))
    return true;
    return isSubtree(root->left,subRoot)||isSubtree(root->right, subRoot);
}

二叉树遍历：

二叉树遍历_牛客题霸_牛客网

思路：

前序遍历插入+中序遍历输出（easy！）

代码如下：

#include <stdio.h>
typedef struct TreeNode
{
    struct TreeNode*left;
    struct TreeNode*right;
    char val;
}TreeNode;
 TreeNode* per_order(char *arr,int *size)
 {
    if(arr[*size] == '#')
    {
        (*size)++;
        return NULL;
    }
    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
    if(root == NULL)
    {
        perror("malloc::error");
        exit(-1);
    }
    root->val = arr[(*size)++];
    root->left = per_order(arr,size);
    root->right = per_order(arr,size);
    return root;
 }
void middle_order(TreeNode*root)
{
    if(root == NULL)
    return ;
    middle_order(root->left);
    printf("%c ",root->val);
    middle_order(root->right);
}
int main() 
{
    char arr[100];
    scanf("%s",arr);
    int n = 0;
    TreeNode* root= per_order(arr,&n);
    middle_order(root);
    return 0;
}