二叉树Leetcode/牛客网典型习题

单值二叉树

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

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

思路：遍历整个二叉树并且判断当前节点与左子树值是否相同，当前节点与右子树值是否相同

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

二叉树的前序遍历

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

int TreeSize(struct TreeNode *root)
{
    if (root == NULL)
        return 0;
    return TreeSize(root->left) + TreeSize(root->right) + 1;
}
void _preorderTraversal(struct TreeNode* root, int *pa, int * i)
{
    if (root == NULL)
        return;
    pa[(*i)++] = root->val;//	因为每次i都要变 要传地址
    _preorderTraversal(root->left, pa, i);
    _preorderTraversal(root->right, pa, i);
}
int* preorderTraversal(struct TreeNode* root, int* returnSize){
    *returnSize = TreeSize(root);
    struct TreeNode *a = (struct TreeNode*)malloc(sizeof(struct TreeNode) * (*returnSize));
    int i = 0;
    _preorderTraversal(root, a, &i);
    return a;
}

二叉树的中序遍历

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

int TreeSize(struct TreeNode *root)
{
    if (root == NULL)
        return 0;
    return TreeSize(root->left) + TreeSize(root->right) + 1;
}
void _inorderTraversal(struct TreeNode* root, int* a, int* i)
{
    if (root == NULL)
        return NULL;
    _inorderTraversal(root->left, a, i);
    a[(*i)++] = root->val;
    _inorderTraversal(root->right, a, i);
}
int* inorderTraversal(struct TreeNode* root, int* returnSize){
    int size = TreeSize(root);
    *returnSize = size;
    //  根据二叉树有多少个节点就开辟多大的空间
    struct TreeNode* a = (struct Node *)malloc(sizeof(struct TreeNode) * size);
    int i = 0;
    _inorderTraversal(root, a, &i);
    return a;
}

二叉树的后序遍历

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

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

void _postorderTraversal(struct TreeNode* root, int* a, int* i)
{
    if (root == NULL)
        return NULL;
    _postorderTraversal(root->left, a, i);
    _postorderTraversal(root->right, a, i);
    a[(*i)++] = root->val;
}
int* postorderTraversal(struct TreeNode* root, int* returnSize){
    int size = TreeSize(root);
    *returnSize = size;
    int *a = (struct TreeNode*)malloc(sizeof(struct TreeNode) * size);
    int i = 0;
    _postorderTraversal(root, a, &i);
    return a;
}

相同的树

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
    if (p == NULL && q == NULL)
        return true;
    if (p == NULL || q == NULL)
        return false;
    //  有一个不同就false
    if (p->val != q->val)
        return false;
    return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}

对称二叉树

给你一个二叉树的根节点 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){
    if (root == NULL)
        return true;
    return _isSymmetric(root->left, root->right);
}

另一颗树的子树

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

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

思路：用root的每颗子树都与subRoot进行比较
时间复杂度：
最好情况：O(N)
最坏情况：O(N*N)

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;
        //  如果以root为根节点与subroot相同
    if (isSameTree(root, subRoot))
        return true;
    return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
}