【二叉树leetcode】

1. 单值二叉树

965. 单值二叉树

如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。

只有给定的树是单值二叉树时，才返回 true；否则返回 false。

• 解题思路：

求解二叉树的题目，必然运用递归，先判断root节点与其子节点是否符合单值二叉树，然后采用这种方法将整棵树递归遍历一遍。

代码实现：

bool isUnivalTree(struct TreeNode* root){
     //空树也符合
     if(root == NULL)
     {
         return true;
     }
     //判断一个节点的左节点是否存在且值是否相同
     if(root->left && root->left->val != root->val)
     {
         return false;
     }
     if(root->right && root->right->val != root->val)
     {
         return false;
     }
     //递归到子树 左右子树都得符合
      return isUnivalTree(root->left) && isUnivalTree(root->right);
}

2.检查两颗树是否相同

100. 相同的树

给你两棵二叉树的根节点 p 和 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->val != q->val)
     {
         return false;
     }
     //递归 左与左 右与右
     return isSameTree(p->left,q->left) && isSameTree(p->right,q->right);
}

3.对称二叉树

101. 对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

• 解题思路：

对称二叉树，与上一题相同二叉树相似，可以将root的左右子树看作两棵树来比较，与相等二叉树不同的是仅是判断条件改变。

bool _isSymmetric(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 _isSymmetric(root1->left,root2->right) &&
    _isSymmetric(root1->right,root2->left);
}

bool isSymmetric(struct TreeNode* root){

     
     return _isSymmetric(root->left,root->right);
}

4.另一棵树的子树

572. 另一棵树的子树

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

• 解题思路：

从root节点开始与子树对比，先对比左边再对比右边，是否是相同子树和上一题方法相同，左右子树中有与另一棵子树相同的就行。

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;
     }
     if(isSameTree(root,subRoot))
     {
         return true;
     }
     return isSubtree(root->left,subRoot) || isSubtree(root->right,subRoot);
}

5.二叉树翻转

226. 翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

• 解题思路：

先翻转root节点的左右节点，然后遍历其左右节点，递归完成，交换节点就是交换节点的指针就行。

struct TreeNode* invertTree(struct TreeNode* root){
      if(root == NULL)
      {
          return NULL;
      }
      struct TreeNode* tmp = root->left;
      root->left = root->right;
      root->right = tmp;
      invertTree(root->left);
      invertTree(root->right);
      return root;
}

6.二叉树的构建及遍历

二叉树遍历

描述：

编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。

输入描述：

输入包括1行字符串，长度不超过100。

输出描述：

可能有多组测试数据，对于每组数据， 输出将输入字符串建立二叉树后中序遍历的序列，每个字符后面都有一个空格。 每个输出结果占一行。

• 解题思路：

按照前序遍历的数组的顺序来构建二叉树，在将其按中序遍历打印。

#include<stdio.h>
#include<stdlib.h>

struct TreeNode
{
    char val;
    struct TreeNode* left;
    struct TreeNode* right;
};


void InOrder(struct TreeNode* root)
{
    if(root == NULL)
    {
        return;
    }
    InOrder(root->left);
    printf("%c ",root->val);
    InOrder(root->right);
}

struct TreeNode* TreeCreate(char* str,int* pi)
{
       if(str[*pi] == '#')
       {
          (*pi)++;//空节点跳过
          return NULL;
       }
       struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
       root->val = str[(*pi)++];
       root->left = TreeCreate(str,pi);
       root->right = TreeCreate(str,pi);
       return root;
}

int main()
{
    char str[100];
    scanf("%s",str);
    
    int i = 0;
    struct TreeNode* root = TreeCreate(str,&i);

    InOrder(root);

    return 0;
}

7.二叉树的前序遍历

144. 二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

• 解题思路：

将二叉树节点的值按照前序遍历的循序放入数组中。

int TreeSize(struct TreeNode* root)
{
    return root == NULL ? 0 : TreeSize(root->left)+TreeSize(root->right)+1;
}

void prevorder(struct TreeNode* root,int* a,int* pi)
{
    if(root == NULL)
    {
        return;
    }
    a[(*pi)++] = root->val;
    prevorder(root->left,a,pi);
    prevorder(root->right,a,pi);
}

int* preorderTraversal(struct TreeNode* root, int* returnSize){
    //数组个数
    *returnSize = TreeSize(root);
    int* a = (int*)malloc(*returnSize * sizeof(int));
    int i = 0;
    prevorder(root,a,&i);

    return a;
}

8.二叉树中序遍历

94. 二叉树的中序遍历

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

• 解题思路：

同上，中序遍历顺序放入数据。

int TreeSize(struct TreeNode* root)
{
    return root == NULL ? 0 : TreeSize(root->left)+TreeSize(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;
    inorder(root->right,a,pi);
}

int* inorderTraversal(struct TreeNode* root, int* returnSize){
     *returnSize = TreeSize(root);
     int* a = (int*)malloc(*returnSize * sizeof(int));
     int i = 0;
     inorder(root,a,&i);
     return a;
}

9.二叉树的后序遍历

145. 二叉树的后序遍历

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

• 解题思路：

同上，按照后序遍历的循序放入数据

int TreeSize(struct TreeNode* root)
{
    return root == NULL ? 0 : TreeSize(root->left)+TreeSize(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;
}


int* postorderTraversal(struct TreeNode* root, int* returnSize){
     *returnSize = TreeSize(root);
     int* a = (int*)malloc(*returnSize*sizeof(int));
     int i = 0;
     postorder(root,a,&i);
     return a;
}