二叉树算法-初阶

Posted 2021-07-18 蚍蜉撼树谈何易

二叉树初阶问题

• 二叉树的构建/遍历问题
• 判断是否为平衡二叉树
• 子树的判定
• 对称二叉树
• 判断两个树是否相同
• 二叉树的反转
• 二叉树的最大深度
• 单值二叉树

二叉树的构建/遍历问题

二叉树的定义问题

typedef char datatype;
struct Binarytree
{
    datatype val;
    struct Binarytree *left;//存储的是左孩子结点
    struct Binarytree*right;//存储的是右孩子结点
};

二叉树的构建

struct Binarytree*my_malloc(datatype val)
{
    struct Binarytree*newnode=(struct Binarytree*)malloc(sizeof(struct Binarytree));
    if(newnode==NULL)
    {
        return NULL;
    }
    newnode->left=newnode->right=NULL;
    newnode->val=val;
    return newnode;
}

struct Binarytree*create(const char str[],int size,int *index)
{
    struct Binarytree*root=NULL;
    if(str[*index]!='#'&&str[*index]!='\\0')
    {
        root=my_malloc(str[*index]);
        (*index)++;
        root->left=create(str,size,index);
        (*index)++;
        root->right=create(str,size,index);
    }
    return root;
}

二叉树的中序遍历

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

二叉树的销毁

void destory(struct Binarytree* root)
{
	if (root == NULL)
	{
		return;
	}
	destory(root->left);
	destory(root->right);
	free(root);
}

leecode链接二叉树构建及遍历

判断是否为平衡二叉树

平衡二叉树的概念：
一个二叉树的左右结点的子树高度不大于1，称为平衡二叉树。

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


bool isBalanced(struct TreeNode* root){

    if(root==NULL)
   {
      return true;

   }
   int h1=by_high(root->left);//对它的左孩子高度判断
   int h2=by_high(root->right);//对它的右孩子高度判断
   if(fabs(h1-h2)>1)
   {
       return false;
   }
   return isBalanced(root->left)&&isBalanced(root->right);
}

leecode链接：
平衡二叉树

子树的判定

bool compare (struct TreeNode* p1,struct TreeNode* p2)
{
    if(!p1&&!p2) return true;//如果此时父树走到任意一侧结尾，子树也走到结尾，此时两树相同
    if(!p1||!p2) return false;//不一样的话，返回false，重新比对另一边的树
    if(p1->val!=p2->val) return false;
    return compare(p1->left,p2->left)&&compare(p1->right,p2->right);
}
bool isSubtree(struct TreeNode* s, struct TreeNode* t){
    if(!s) return false;
    return compare(s,t)||isSubtree(s->left,t)||isSubtree(s->right,t);
}

子树的判定

对称二叉树

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

对称二叉树

判断两个树是否相同

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

判断两树相同

二叉树的反转

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

二叉树反转

二叉树的最大深度

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

二叉树最大深度

单值二叉树

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

单值二叉树