二叉树oj

文章目录

   1. 单值二叉树

   2. 检查两颗树是否相同。

   3. 对称二叉树。

   4. 二叉树的前序遍历。

   5. 另一颗树的子树。

   6.二叉树的构建及遍历。

   7.判断一颗二叉树是否是平衡二叉树。

   8.翻转二叉树。

---

文章内容

   1. 单值二叉树

    力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

思路：此题为二叉树遍历问题。首先假设根节点的值作为标准值，在遍历的过程中如果有别的节点的值与其不相等则为假。

          递归的返回条件：

        第一：当目前节点为空的时候我们返回真。

        第二：当目前节点的左右孩子不为空，并且值左右孩子的值不等于根的值的时候我们返回假。

        如果当前节点的值不符合以上两种情况，则继续往下遍历。

 

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. 检查两颗树是否相同。

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台         力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

         思路：我们同时从根节点出发，然后来对比他们的左右子树，左右子树的状态和值要相同，才能返回真。

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.对称二叉树。

   力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

       

   思路：首先要判断两个根节点是否为空，如果为空，然后返回真，然后就是判断两颗树是不是相同的子树。

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

}

bool isSymmetric(struct TreeNode* root){

    if(root == NULL)
    {
        return true;
    }

    return isSymmetricsubTree(root->left , root->right);

}

    4. 二叉树的前序遍历。

        力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

思路： 输出的结果是一个数组，所以我们首先要遍历节点的个数，构造与之相同大小的数组。

             堆区开辟内存存储遍历二叉树的，避免函数返回后造成野指针问题。

int Bsize(struct TreeNode*root)
{
        if(root == NULL)
        {
            return 0;
        }

        return Bsize(root->left)+Bsize(root->right)+1;

}


 void postorder(struct TreeNode* root, int* a,int* i)
 {
        if(root == NULL)
        {
            return;
        }

        a[(*i)++] = root->val;
        postorder(root->left,a,i);
      
        postorder(root->right,a,i);
      

 }

int* preorderTraversal(struct TreeNode* root, int* returnSize){
        int* a,i;
        *returnSize = Bsize(root);
        a = (int*)malloc(sizeof(int) * (*returnSize));
    

        i=0;
        postorder(root ,a ,&i );
        //传递i的地址，传址能改变实参
        return a;
}

5.另一颗树的子树。

    力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

 思路：我们分别那root 的左右节点去和subroot 比较他们是否为相同的树。

ool 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;
    //root为空则不为相同的树
    }

    if( isSameTree(root,subRoot))
    {
        return true;
    }

    return isSubtree(root->left,subRoot) || isSubtree(root->right,subRoot);

}

6.二叉树的构建及遍历。

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

思路：本题并非力扣上的接口题，我们要自己写主函数，还要创建数组。

 

         程序的逻辑图打开如上，访问到 # 便返回空，再创建新节点之后 pi 已经++，所以创建左子树的便不用再++，本题创建节点的思路和先序遍历的思路是一样的，先创建根节点，然后左子树，然后右子树。

#include 
#include

typedef char BTDataType;
typedef struct BinaryTreeNode
{
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
	BTDataType data;

}BTNode;


BTNode* BuyNode(BTDataType x)
{
	BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->left = NULL;
	newnode->right = NULL;

	return newnode;
}

BTNode* creattree(char a[] , int* i)
{
    if(a[(*i)] == '#')
    {
        (*i)++;
        return NULL;
    }

    BTNode* root = BuyNode(a[(*i)++]);
    root->left = creattree(a,i);
    root->right = creattree(a,i);
    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] = {0};
    scanf("%s",a);
    int i = 0;
    BTNode* root = creattree(a,&i);
    inorder(root);

    return 0;
}

7.判断一颗二叉树是否是平衡二叉树。

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

 思路：

        通过算出左右子树的深度，来比较是否为平衡二叉树。

 8.翻转二叉树。

        力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

思路：交换根的左右节点

 

void reversetree(struct TreeNode* root)
{

    if(root)
    {
    struct TreeNode*  tmp = root->left;
    root->left = root->right;
    root->right = tmp;

    reversetree(root->left);
    reversetree( root->right);

    }

}

struct TreeNode* invertTree(struct TreeNode* root){

    if(root == NULL)
    {
        return NULL;
    }

    reversetree(root);
    return root;

}