二叉树ＯJ题解析

分享一下着两天做的二叉树相关OJ题

11-13

单值二叉树

问题描述

https://leetcode-cn.com/problems/univalued-binary-tree/

思路分析

判断每个结点是否与孩子节点相等即可，每次比较该节点与某一孩子结点，然后再比较另一个结点，根据传递性可知，只要有一个不成立就返回失败，否则就递归往下比较。

代码实现

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

相同的树

问题描述

https://leetcode-cn.com/problems/same-tree/submissions/

思路分析

逐个结点比较即可。

代码实现

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

对称二叉树

问题描述

https://leetcode-cn.com/problems/symmetric-tree/

思路分析

是否关于中心对称，需要比较左右子树是否对称，左子树的左子树与右子树的右子树比较是否相等，左子树的右子树与右子树的左子树比较是否相等。比较相等代码类似上题。

代码实现

bool _isSymmetricTree(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 _isSymmetricTree(p->left,q->right)&&_isSymmetricTree(p->right,q->left);
}
bool isSymmetric(struct TreeNode* root)
{
    if(root==NULL)
        return true;
    return _isSymmetricTree(root->left,root->right);
}

另一颗树的子树

问题描述

https://leetcode-cn.com/problems/subtree-of-another-tree/

思路分析

用root的每个子树跟 subRoot 比较是否相等。时间复杂度最好为O（N）最坏为O(N^2)

代码实现

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;
    //比较以该结点为根的树与subRoot比较是否相等
    if(isSameTree(root, subRoot))
        return true;
    return isSubtree(root->left,subRoot)||isSubtree(root->right,subRoot);

}

二叉树的前序遍历

问题描述

https://leetcode-cn.com/problems/binary-tree-preorder-traversal/

思路分析

它要求将遍历的值放在数组里面返回，那么就要先计算出树节点的个数，然后为数组开辟空间，再进行前序遍历即可，但要注意下标的传值。

代码实现

int BinaryTreeSize(struct TreeNode* root)
{
	return root == NULL ? 0 : BinaryTreeSize(root->left)+ BinaryTreeSize(root->right) + 1;
}
void _preorderTraversal(struct TreeNode* root,int* a,int* pi)
{
    if(root==NULL)
        return;
    a[(*pi)++]=root->val;
    _preorderTraversal(root->left,a,pi);
    _preorderTraversal(root->right,a,pi);

}
int* preorderTraversal(struct TreeNode* root, int* returnSize)
{
    int size=BinaryTreeSize(root);
    int* a=(int*)malloc(sizeof(int)*size);
    *returnSize=size;
    int i=0;
    _preorderTraversal(root,a,&i);
    return a;
}

二叉树构建及遍历

问题描述

https://www.nowcoder.com/practice/4b91205483694f449f94c179883c1fef?tpId=60&&tqId=29483&rp=1&ru=/activity/oj&qru=/ta/tsing-kaoyan/question-ranking

思路分析

使用前序遍历建立结点，遇到#号返回链接。

代码实现

#include<stdio.h>
#include<stdlib.h>
typedef struct BinaryTreeNode
{
    struct BinaryTreeNode* left;
    struct BinaryTreeNode* right;
    char val;
}BTNode;
//传i的地址，这样才能改变同一个i，遍历整个数组
BTNode* CreatTree(char* arr, int* pi)
{
    if (arr[*pi] == '#')
    {
        (*pi)++;
        return NULL;
    }
    BTNode* root = (BTNode*)malloc(sizeof(BTNode));
    if (root == NULL)
        exit(-1);
    root->val = arr[(*pi)++];
    root->left = CreatTree(arr, pi);
    root->right = CreatTree(arr, pi);

    return root;
}
void InOrder(BTNode* root)
{
    if (root == NULL)
    {
        return;
    }
    InOrder(root->left);
    printf("%c ", root->val);
    InOrder(root->right);
}
int main()
{
    char arr[100];
    scanf("%s", arr);
    int i = 0;
    BTNode* root = CreatTree(arr, &i);
    InOrder(root);
    return 0;
}

11-14

翻转二叉树

问题描述

https://leetcode-cn.com/problems/invert-binary-tree/

思路分析

遇到二叉树问题，首先想到分治，我们可以递归让左右子树分别翻转。

代码实现

struct TreeNode* invertTree(struct TreeNode* root){
    if(root==NULL)
        return NULL;
    //保留左子树的地址
    struct TreeNode* tmp=root->left;
    //让右子树翻转，然后链接到左孩子    
    root->left=invertTree(root->right);
    //让左子树翻转，然后链接到右孩子
    root->right=invertTree(tmp); 
	//返回翻转后的根节点
    return root;
}

二叉树的最大深度

问题描述

https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/

思路分析

分治查找左右子树的高度，返回较大值即可。

代码实现

int maxDepth(struct TreeNode* root)
{
    if(root==NULL)
        return 0;
    int left=maxDepth(root->left)+1;//1是当前结点的高度
    int right=maxDepth(root->right)+1;
    if(left>right)
        return left;
    else
        return right;
}

平衡二叉树

问题描述

https://leetcode-cn.com/problems/balanced-binary-tree/

思路分析

判断它的每个结点的左右子树是否平衡即可，需要用到求高度函数。

代码实现

int maxDepth(struct TreeNode* root)
{
    if(root==NULL)
        return 0;
    int left=maxDepth(root->left)+1;
    int right=maxDepth(root->right)+1;
    if(left>right)
        return left;
    else
        return right;
}
bool isBalanced(struct TreeNode* root)
{
    if(root==NULL)
        return true;
    //判断root是否平衡
    int left=maxDepth(root->left);
    int right=maxDepth(root->right);
    if(abs(left-right)>1)
        return false;
	//判断root的左右分别是否平衡
    return isBalanced(root->left)&&isBalanced(root->right);
}