第八章查找

9.1

(1)无序表：顺序查找不成功时，查找长度为n+1；成功时，平均查找长度为1/(n+1)*(1+2+…+(n+1))=(n+2)/2；两者不相同。

（2）表中只有一个关键字等于给定值k 的记录，无序表、有序表：顺序查找成功时，平均查找长度均为1/(n)*(1+2+…+n)=(n+1)/2；两者相同。

（3）表中只有m 个关键字等于给定值k 的记录，无序表：ASL=n+1；有序表：ASL=（n+1）/2+m ；两者不相同。 9.3

ASL=1/10（1+2*2+4*3+3*4）=2.9 9.11

9.14

6

5

2 8

3 1

9

7 4

10

删除50后

删除68后

0 1 2 3 4

5 6 7 8 9

10

ASL=（4*1+2*2+3+6）/8=17/8 9.25

int Search-Seq(SSTable ST, KeyType key){

//在顺序表ST 中顺序查找其关键字等于key 的数据元素，ST 按关键字自大至小有序， //若找到，则函数值为该元素在表中的位置，否则为0 ST.elem[ST.length+1].key=key;

for (i=1; ST.elem[i].key>key; ++i);

if (ST.elem[i].key==key)&&(i<=ST.length) return i

else return 0 ;

}//Search-Seq

9.31

TelemType Maxv(Bitree T){

//返回二叉排序树T中所有结点的最大值

for (p=T; p->rchild; p=p->rchild);

return p->data;

}//Maxv

TelemType Minv(Bitree T){

//返回二叉排序树T中所有结点的最小值

for (p=T; p->lchild; p=p->lchild);

return p->data;

}//Minv

Status IsBST(Bitree T){

//判别T是否为二叉排序树

if (!T) return OK;

else if

((!T->lchild)||((T->lchild)&&(IsBST(T->lchild)&&(Maxv(T->lchild)data))) &&((!T->rchild)||((T->rchild)&&(IsBST(T->rchild)&&(Minv(T->rchild)>T->data)))

return OK

else return ERROR;

}//IsBST

9.33

Status OutputGEx(Bitree T, TelemType x){

//从大到小输出给定二叉排序树T中所有值不小于x的数据元素

if (T) {

if (OutputGEx(T->rchild, x))

if (T->data>=x) {

print(T->data);

if (OutputGEx(T->lchild, x)) return OK;

}

else return OK;

}

else return OK;

}//OutputGEx

第九章查找

9.25

int Search_Sq(SSTable ST,int key)//在有序表上顺序查找的算法,监视哨设在高下标端

{

ST.elem[ST.length+1].key=key;

for(i=1;ST.elem[i].key>key;i++);

if(i>ST.length||ST.elem[i].key

return i;

}//Search_Sq

分析:本算法查找成功情况下的平均查找长度为ST.length/2,不成功情况下为ST.length.

9.26

int Search_Bin_Digui(SSTable ST,int key,int low,int high)//折半查找的递归算法

{

if(low>high) return 0; //查找不到时返回0

mid=(low+high)/2;

if(ST.elem[mid].key==key) return mid;

else if(ST.elem[mid].key>key)

return Search_Bin_Digui(ST,key,low,mid-1);

else return Search_Bin_Digui(ST,key,mid+1,high);

}

}//Search_Bin_Digui

9.27

int Locate_Bin(SSTable ST,int key)//折半查找,返回小于或等于待查元素的最后一个结点号

{

int *r;

r=ST.elem;

if(key

else if(key>=r[ST.length].key) return ST.length;

low=1;high=ST.length;

while(low<=high)

{

mid=(low+high)/2;

if(key>=r[mid].key&&key

return mid;

else if(key

else low=mid;

} //本算法不存在查找失败的情况,不需要return 0;

}//Locate_Bin

9.28

typedef struct {

int maxkey;

int firstloc;

} Index;

typedef struct {

int *elem;

int length;

Index idx[MAXBLOCK]; //每块起始位置和最大元素,其中idx[ 0 ]不利用,其内容初始化为{0,0}以利于折半查找

int blknum; //块的数目

} IdxSqList; //索引顺序表类型

int Search_IdxSeq(IdxSqList L,int key)//分块查找,用折半查找法确定记录所在块,块内采用顺序查找法{

if(key>L.idx[L.blknum].maxkey) return ERROR; //超过最大元素

low=1;high=L.blknum;

found=0;

while(low<=high&&!found) //折半查找记录所在块号mid

{

mid=(low+high)/2;

if(key<=L.idx[mid].maxkey&&key>L.idx[mid-1].maxkey)

found=1;

else if(key>L.idx[mid].maxkey)

low=mid+1;

else high=mid-1;

}

i=L.idx[mid].firstloc; //块的下界

j=i+blksize-1; //块的上界