第七章 查找

7_1

05、写出折半查找的递归算法，初始调用时，low=1,high=ST.length。

//顺序表存储结构 
typedef  struct{
	ElemType data[MaxSize];
	int length;
}SqList;

int BinarySearch_Recurse(SqList L,ElemType key,int low,int high)
{
	int mid;
	low=1,high=L.length;
	while(low<=high)
	{
		mid=low+high>>1;
		if(L.data[mid]>key)
			BinareSearch_Recurse(L,key,low,mid-1);
		else if(L.data[mid]<key)
			BinarySearch_Recurse(L,key,mmid+1,high);
		else
			return mid;
	}
}

7_3

06、试编写一个算法，判断给定的二叉树是否是二叉排序树

//思路:二叉树中序遍历的改造 

KeyType predt=-32767;//predt为全局变量 保存当前结点中序前驱的值 初值为-∞ 
int JudgeBST(BiTree T)
{
	int b1,b2;//保存左、右子树的返回值
	if(T==NULL)
		return 1;//空树也是二叉排序树
	else
	{
		b1=JudgeBST(bt->lchild);//判断左子树是否是二叉排序树 
		if(b1==0||predt>=bt->data)//若左子树返回值为0或前驱大于等于当前结点 
			return 0;//则不是二叉排序树 
		predt=bt->dat;//保存当前结点的关键字 
		b2=JudgeBST(bt->rchild);//判断右子树 
		return b2;//返回右子树的结果 
	} 
 } 

07、设计一个算法，求出指定结点在给定二叉排序树中的层次

//求给定结点在二叉树中的层次
int level(BiTree bt,BiTNode *p)
{
	int n=0;
	BiTree T=bt;
	if(bt!=NULL)
	{
		n++;
		while(p->data!=T->data)
		{
			if(p->data<T->data)//若给定结点的值小于当前结点的值 
				T=T->lchild;//向左孩子深入 
			else//否则 
				T=T->rchild;//向右孩子深入 
			n++;//层次加1 
		}
	}
	
	return n;
 }

08、利用二叉树遍历的思想编写一个判断此二叉树是否是平衡二叉树的算法

//思路：
//设置balance变量 balance为1表示是平衡二叉树 balance为0表示不是平衡二叉树
//如果是空树 则h(高度)为0 balance为1 若仅有根结点 则h=1 balance为1
void Judge(BiTree bt,int &balance,int h)
{
	int bl,hl,br,hr;//分别表示左子树的balance和高度 以及右子树的balance和高度
	if(bt==NULL)
	{
		h=0;
		balance=1;
	}else if(bt->lchild==NULL&&bt->rchild==NULL)
	{
		h=1;
		balance=1;
	}else
	{
		Judge(bt->lchild,bl,hl);//递归判断左子树
		Judge(bt->rchild,br,hr);//递归判断右子树
		h=(hl>hr?hl:hr)+1;//高度为左右子树最大高度+1
		if(abs(hl-hr)<=1)
			balance=bl&br;//左右子树都平衡时 二叉树平衡 
		else
			balance=0;
		  
	} 
 }

09、设计一个算法，求出给定二叉排序树的最小和最大的关键字

void BST_Max_Min(BSTree bt,ElmeType &Max,ElemType &Min)
{
	BSTNode *p=bt,*q=bt; 
	while(p!=NULL)
	{
		p=p->lchild;
	}
	while(q!=NULL)
	{
		q=q->rchild;
	}
	Max=p->data;
	Min=q->data;
}

10、设计一个算法，从大到小输出二叉排序树中所有值不小于k的关键字

//从大到小输出 则应先遍历右子树 再访问根结点 后遍历左子树 
void print_NotBelowK(BSTree bt,ElemType k)
{
	BSTNode *p=bt;
	if(bt==NULL)
		return;
	if(p->rchild!=NULL)
		print_NotBelowK(p->rchild,k); //递归输出右子树结点 
	if(p->data<=k)//满足条件 则输出 
		print(bt->data);
	if(p->lchild!=NULL)//递归输出左子树结点 
		print_NotBelowK(p->lchild,k); 
}
 

11、

//思路：递归 查找 
typedef struct BSTNode{
	BSTNode *lchild,*rchild;
	ElemType data;
	int count; 
}BSTNode,*BSTree;

BSTNode* Search_kth(BSTree bt,int k)
{
	if(k<1||k>bt->count) return NULL;//不存在这样的k
	if(bt->lchild==NULL)//左子树不存在
	{
		if(k==1) 
			return bt;//k为1 则该结点为所求
		else 
		 	return Search_kth(bt->rchild,k-1);//因为根结点一定小于其右子树的值 所以在右子树上查找第k-1小的元素 
	}else//左子树不空 
	{
		if(bt->lchild->count==k-1) return bt;
		if(bt->lchild->count>k-1) 
			return Search_kth(bt->lchild,k);//当左子树上的结点个数大于k-1 说明第k小的结点在左子树中 
		if(bt->lchild->count<k-1) //当左子树上的结点个数小于k-1 说明第k小的结点在右子树中
			return Search_kth(bt->rchild,k-(bt->lchild->count+1)); //在右子树中找 此时k=k-(bt->lchild->count+1)
	} 
}