算法小练（二叉树）

算法题小练
1.判断二叉树是否是平衡二叉树
判断左右子树的深度差是否<=1，若小于等于1则为平衡二叉树

int max(int a,int b){return a>b? a:b;}
int min(int a,int b){return a<b? a:b;}
int max_depth(node_t *root){
	if(root==NULL)return 0;
	int left=max_depth(root->left);
	int right=min_depth(root->right);
	return max(left,right)+1;
}

int min_depth(node_t *root){
	if(root==NULL)return 0;
	int left=max_depth(root->left);
	int right=min_depth(root->right);
	return min(right,left)+1;
}

int balance(){
	return (max_depth(root)-min_depth(root))<=1;
}

2.判断一棵树是否是二叉查找树；
当前节点的左子树是一个二分查找树
当前节点的右子树是一个二分查找树
&&cur->data>左子树的根节点
&&cur->data<右子树的根节点

int is_bst(node_t *root,int ,int min_val,int max_val){
	if(root==NULL)return 1;
	if(root->data<min_val||root->data>max_val)return 0;
	return is_bst(root->left,min_val,root->data)&&
			is_bst(root->right,root->data,max_val);
}

3.判断两个二叉树是否相等

int is_like(node_t *t1,node_t *t2){
	if(t1==NULL&&t2==NULL)return 1;
	if(t1!=NULL&&t2!=NULL){
		return t1->data==t2->data&&
		is_like(t1>left,t2->left)&&
		is_like(t1->right,t2->right);
		}
	return 0;
}

4.产生一个二叉镜像树

node_t *mirror(node_t *root){
	if(root!=NULL){
		root->left=mirror(root->left);
		root->right=mirror(root->right);
		node_t *p=root->left;
		root->left=root->right;
		root->right=p;
	}
	return root;
}

5.将数组转换为二叉树

node_t *sort_array_to_bst(int arr[],int left,int right){
	if(left>right)return NULL;
	int mid=(left+right)>>1;
	node_t *p=create_node(arr[mid]);
	p->left=sort_array_to_bst(arr,left,mid-1);
	p->left=sort_array_to_bst(arr,mid+1,right);
	return p;
}

6.知前序中序求二叉树

node_t *create_node(int i){
	node_t *p = malloc(sizeof(node_t));
	p->data=i;
	p->left=p->right=NULL;
	return p;
}

node_t *rebulid(int pre[],int s1,int e1,int mid[]，int s2,int e2)
{
	if(s1>e1||s2>e2)return NULL;
	int root=pre[s1];
	int i;
	for(i=s2;mid[i]!=root&&i<e2;i++)
	{
	;
	}
	node_t *rootNode=create_node(root);
	rootNode->left=rebulid(pre,s1+1,s1+i-s2,mid,s2,i-1);
	rootNode->right=rebulid(pre,s1+i-s2+1,e1,mid,i+1,e2);
	return rootNode;
}