二叉搜索树

二叉搜索树 BST
非空左子树的所有键值均小于其根节点的键值
非空右子树的所有键值均大于其根节点的键值
左右子树均为二叉搜索树

最小元素一定在最右子树；最大元素一定在最左子树

二叉搜索树操作的特别函数
Position Find(ElementType X,BinTree BST)
Position FindMin(BinTree BST)
Position FindMax(BinTree BST)
Position Insert(ElementType X,BinTree BST)
Position Delete(ElementType X,BinTree BST)

二叉搜索树操作函数的定义
代码如下：

// 二叉树查找的尾递归
Position Find(ElementType X,BinTree BST)
{
    if(!BST) return NULL; //首先排除是否为空，若空，则查找失败，返回空
    if(X>BST->Data)
        return Find(X,BST->Right);
    if(X<BST->Data)
        return Find(X,BST->Left);
    else  //等效于X==BST->Data,因为只剩下这一种情况
        return BST; //查找成功，返回节点的地址
}

//二叉树查找的迭代查找
Position IterFind(ElementType X,BinTree BST)
{
    while(BST){  //若BST为空，则直接返回NULL
    if(X>BST->Data)
        BST = BST->Right;
    else if(X<BST->Data)
        BST = BST->Left;
    else  //等效于X==BST->Data,因为只剩下这一种情况
        return BST; //查找成功，返回BST
    }
return NULL;//查找失败
}

/*查找最小元素*/
Position FindMin(BinTree BST)
{
    if(!BST) return NULL; //空二叉树，返回NULL
    else if（!BST->Left）//看左节点是否为空
        return BST; //若为空，则说明当前节点为最左节点
    else  //树不为空，左节点不为空
        return FindMin(BST->Left);//沿左分支继续查找
}

/*查找最大元素*/
Position FindMax(BinTree BST)
{   if(BST)
        while (BST->Right) BST = BST->Right; //当前节点的右子节点不为空，说明还有右节点
          //沿右分支继续查找
        return BST;//当BST->Right为空，说明是最右
}

/*插入*/
BinTree Insert(ElementType X,BinTree BST)
{
    if(!BST){ //若树为空,则生成并返回一 个节点的二叉树
        BST =malloc(sizeof(struct TreeNode));
        BST->Data = X;
        BST->Left = BST->Right = NULL;
    }
    else //开始找到要插入的节点
        {   if(X<BST->Data)
                BST->Left = Insert(X,BST->Left); //递归插入左子树
            else if(X>BST->Data)
                BST->Right = Insert(X,BST->Right);//递归插入右子树
        }
        //如果元素X已存在，则什么都不做
    return BST ;
}

/*删除*/
BinTree Delete(ElementType X,BinTree BST)
{   Position Tmp;
    if(!BST)printf("要删除的元素未找到"); //树为空
    else if(X<BST->Data)
        BST->Left = Delete(X,BST->Left);
    else //找到要删除的节点
        if(BST->Left && BST->Right){//被删除的节点有左右两个节点
            Tmp = FindMin(BST->Right);//在右子树中找到最小节点填充最小节点
            BST->Data = Tmp->Data;
            BST->Right = Delete(BST->Data,BST->Right); //在删除节点的右子树中删除最小元素
           }
         else {  //被删除节点有一个或无子节点
             Tmp = BST;
             if(!BST->Left) //有右孩子或无子节点
                 BST = BST->Right;
             else if(!BST->Right) //有左孩子或无节点
                 BST = BST->Left;
             free(Tmp);
         }
   return BST;   
}

两个序列是否对应相同搜索树的判别
给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可由多种不同的插入序列得到。例如序列{2,1，3} 和{2,3，1}插入初始为空的二叉搜索树，都能的到同样的结果。问题：对于输入的各种插入序列，你需要判断它们是否能够生成一样的二叉搜索树？

代码如下：

/*搜索树的表示*/
typedef struct TreeNode*Tree;
struct TreeNode{
	int v; //定义程序的标志
	Tree Left,Right;//定义Tree类型变量，也就是结点的指针
	int flag; //定义结点的标志
}

/*创建树的结点*/
Tree NewNode(int V)  //node，结点
{	Tree T=(Tree)malloc(sizeof(struct TreeNode))
	T->v=V;
	T->Left = T->right = NULL;
	T->flag=0;
	return T;
}

/*树结点的插入*/
Tree Insert(Tree T,int V)
{	if(!T) T=NewNode(V);
	else{
		if(V>T->v)
			T->Right=Insert(T->Right,V);
		else
			T->Left=Insert(T->Left,V);
	}
	return T;
}

/*创建树:输入数据，将它加在树上*/
Tree MakeTree(int N)
{	Tree T;
	int i,V;

	scanf("%d",&V);
	T=NewNode(V);
	for(i=1;i<N;i++){
		scanf("%d",&V);
		T=Insert(T,V);
	}
	return T;
}

/*判别函数*/
int Judge(Tree T,int N)
{
	int i,V,flag = 0;//flag：0代表目前还一致，1代表已经不一致
	scanf("%d",&V);
	if(V!=T->v) flag=1;
	else T->flag=1;
	for(i=1;i<N;i++){
		scanf("%d",&V);
		if((!flag)&&(!check(T,V))) flag=1;
	}
	if(flag) return 0;
	else return ;
}

/*结点标记的清除*/
void ResetT(Tree T) //清除T的各结点的flag标记
{
	if(T->Left) ResetT(T->Left);
	if(T->Right) ResetT(T->Right);
	T->flag = 0;
}

/*释放T的空间*/
void FreeTree(Tree T)
{
	if(T->Left) FreeTree(T->Left);
	if(T->Right) FreeTree(T->Right);
	free(T);
}

/*主函数*/
int main()
{
	int N,L,i;
	Tree T;

	scanf("%d",&N);
	while(N){
		scanf("%d",&L);
		T=MakeTree(N);
		for(i=0;i<L;i++){
			if(Judge(T,N)) printf("Yes\n");
			else printf("No\n");
			ResetT(T);  //清除T的标记flag
		}
		FreeTree(T);//释放结点空间
		scanf("%d",&N);
	}
	return 0;
}