第九章 查找Word格式.docx

第九章 查找Word格式.docx

《第九章 查找Word格式.docx》由会员分享，可在线阅读，更多相关《第九章 查找Word格式.docx（11页珍藏版）》请在冰豆网上搜索。

=high）

if（key>

=r[mid].key&

&

key<

r[mid+1].key）//查找结束的条件

returnmid;

elseif（key<

r[mid].key）high=mid;

elselow=mid;

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

}//Locate_Bin

9.28

typedefstruct{

intmaxkey;

intfirstloc;

}Index;

int*elem;

intlength;

Indexidx[MAXBLOCK];

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

intblknum;

//块的数目

}IdxSqList;

//索引顺序表类型

intSearch_IdxSeq（IdxSqListL,intkey）//分块查找,用折半查找法确定记录所在块,块内采用顺序查找法

L.idx[L.blknum].maxkey）returnERROR;

//超过最大元素

high=L.blknum;

found=0;

=high&

!

found）//折半查找记录所在块号mid

=L.idx[mid].maxkey&

key>

L.idx[mid-1].maxkey）

found=1;

L.idx[mid].maxkey）

low=mid+1;

elsehigh=mid-1;

i=L.idx[mid].firstloc;

//块的下界

j=i+blksize-1;

//块的上界

temp=L.elem[i-1];

//保存相邻元素

L.elem[i-1]=key;

//设置监视哨

for（k=j;

L.elem[k]!

=key;

k--）;

//顺序查找

L.elem[i-1]=temp;

//恢复元素

if（k<

i）returnERROR;

//未找到

returnk;

}//Search_IdxSeq

在块内进行顺序查找时,如果需要设置监视哨,则必须先保存相邻块的相邻元素,以免数据丢失.

9.29

LNode*h;

//h指向最小元素

LNode*t;

//t指向上次查找的结点

}CSList;

LNode*Search_CSList（CSList&

L,intkey）//在有序单循环链表存储结构上的查找算法,假定每次查找都成功

if（L.t->

data==key）returnL.t;

elseif（L.t->

data>

for（p=L.h,i=1;

p->

data!

p=p->

next,i++）;

else

for（p=L.t,i=L.tpos;

L.t=p;

//更新t指针

returnp;

}//Search_CSList

由于题目中假定每次查找都是成功的,所以本算法中没有关于查找失败的处理.由微积分可得,在等概率情况下,平均查找长度约为n/3.

9.30

DLNode*pre;

intdata;

DLNode*next;

}DLNode;

DLNode*sp;

}DSList;

//供查找的双向循环链表类型

DLNode*Search_DSList（DSList&

L,intkey）//在有序双向循环链表存储结构上的查找算法,假定每次查找都成功

p=L.sp;

if（p->

while（p->

key）p=p->

pre;

L.sp=p;

elseif（p->

data<

next;

}//Search_DSList

本题的平均查找长度与上一题相同,也是n/3.

9.31

intlast=0,flag=1;

intIs_BSTree（BitreeT）//判断二叉树T是否二叉排序树,是则返回1,否则返回0

if（T->

lchild&

flag）Is_BSTree（T->

lchild）;

last）flag=0;

//与其中序前驱相比较

last=T->

data;

rchild&

rchild）;

returnflag;

}//Is_BSTree

9.32

intlast=0;

voidMaxLT_MinGT（BiTreeT,intx）//找到二叉排序树T中小于x的最大元素和大于x的最小元素

lchild）MaxLT_MinGT（T->

lchild,x）;

//本算法仍是借助中序遍历来实现

if（last<

x&

T->

=x）//找到了小于x的最大元素

printf（"

a=%d\n"

last）;

=x&

x）//找到了大于x的最小元素

b=%d\n"

T->

data）;

rchild）MaxLT_MinGT（T->

rchild,x）;

}//MaxLT_MinGT

9.33

voidPrint_NLT（BiTreeT,intx）//从大到小输出二叉排序树T中所有不小于x的元素

rchild）Print_NLT（T->

x）exit（）;

//当遇到小于x的元素时立即结束运行

%d\n"

lchild）Print_NLT（T->

//先右后左的中序遍历

}//Print_NLT

9.34

voidDelete_NLT（BiTree&

T,intx）//删除二叉排序树T中所有不小于x元素结点,并释放空间

rchild）Delete_NLT（T->

q=T;

T=T->

lchild;

free（q）;

//如果树根不小于x,则删除树根,并以左子树的根作为新的树根

if（T）Delete_NLT（T,x）;

//继续在左子树中执行算法

}//Delete_NLT

9.35

voidPrint_Between（BiThrTreeT,inta,intb）//打印输出后继线索二叉排序树T中所有大于a且小于b的元素

p=T;

while（!

ltag）p=p->

//找到最小元素

while（p&

b）

a）printf（"

p->

//输出符合条件的元素

rtag）p=p->

rtag;

rchild;

}//转到中序后继

}//while

}//Print_Between

9.36

voidBSTree_Insert_Key（BiThrTree&

T,intx）//在后继线索二叉排序树T中插入元素x

x）//插入到右侧

rtag）//T没有右子树时,作为右孩子插入

p=T->

q=（BiThrNode*）malloc（sizeof（BiThrNode））;

q->

data=x;

rchild=q;

rtag=0;

rtag=1;

rchild=p;

//修改原线索

elseBSTree_Insert_Key（T->

//T有右子树时,插入右子树中

}//if

elseif（T->

x）//插入到左子树中

if（!

lchild）//T没有左子树时,作为左孩子插入

lchild=q;

rchild=T;

//修改自身的线索

//T有左子树时,插入左子树中

}//BSTree_Insert_Key

9.37

StatusBSTree_Delete_key（BiThrTree&

T,intx）//在后继线索二叉排序树T中删除元素x

BTNode*pre,*ptr,*suc;

//ptr为x所在结点,pre和suc分别指向ptr的前驱和后继

last=NULL;

//last始终指向当前结点p的前一个（前驱）

//找到中序起始元素

while（p）

data==x）//找到了元素x结点

pre=last;

ptr=p;

elseif（last&

last->

data==x）suc=p;

//找到了x的后继

last=p;

}//while//借助中序遍历找到元素x及其前驱和后继结点

ptr）returnERROR;

//未找到待删结点

Delete_BSTree（ptr）;

//删除x结点

if（pre&

pre->

rtag）

rchild=suc;

//修改线索

returnOK;

}//BSTree_Delete_key

voidDelete_BSTree（BiThrTree&

T）//课本上给出的删除二叉排序树的子树T的算法,按照线索二叉树的结构作了一些改动

ltag&

rtag）//结点无右子树,此时只需重接其左子树

rtag）//结点无左子树,此时只需重接其右子树

elseif（!

rtag）//结点既有左子树又有右子树

r=T->

r->

s=r;

r=r->

//找到结点的前驱r和r的双亲s

data=r->

//用r代替T结点

if（s!

=T）

s->

rchild=r->

elses->

lchild=r->

//重接r的左子树到其双亲结点上

q=r;

}//else

//删除结点

}//Delete_BSTree

本算法采用了先求出x结点的前驱和后继,再删除x结点的办法,这样修改线索时会比较简单,直接让前驱的线索指向后继就行了.如果试图在删除x结点的同时修改线索,则问题反而复杂化了.

9.38

voidBSTree_Merge（BiTree&

T,BiTree&

S）//把二叉排序树S合并到T中

if（S->

lchild）BSTree_Merge（T,S->

rchild）BSTree_Merge（T,S->

//合并子树

Insert_Key（T,S）;

//插入元素

}//BSTree_Merge

voidInsert_Node（Bitree&

T,BTNode*S）//把树结点S插入到T的合适位置上

data）

rchild）T->

rchild=S;

elseInsert_Node（T->

rchild,S）;

elseif（S->

lchild）T->

lchild=S;

lchild,S）;

S->

lchild=NULL;

//插入的新结点必须和原来的左右子树断绝关系

rchild=NULL;

//否则会导致树结构的混乱

}//Insert_Node

这是一个与课本上不同的插入算法.在合并过程中,并不释放或新建任何结点,而是采取修改指针的方式来完成合并.这样,就必须按照后序序列把一棵树中的元素逐个连接到另一棵树上,否则将会导致树的结构的混乱.

9.39

voidBSTree_Split（BiTree&

A,BiTree&

B,intx）//把二叉排序树T分裂为两棵二叉排序树A和B,其中A的元素全部小于等于x,B的元素全部大于x

lchild）BSTree_Split（T->

lchild,A,B,x）;

rchild）BSTree_Split（T->

rchild,A,B,x）;

//分裂左右子树

=x）Insert_Node（A,T）;

elseInsert_Node（B,T）;

//将元素结点插入合适的树中

}//BSTree_Split

T）T=S;

//考虑到刚开始分裂时树A和树B为空的情况

data）//其余部分与上一题同

}//Insert_Key

9.40

intbf;

intlsize;

//lsize域表示该结点的左子树的结点总数加1

BlcNode*lchild,*rchild;

}BlcNode,*BlcTree;

//含lsize域的平衡二叉排序树类型

BTNode*Locate_BlcTree（BlcTreeT,intk）//在含lsize域的平衡二叉排序树T中确定第k小的结点指针

T）returnNULL;

//k小于1或大于树结点总数

lsize==k）returnT;

//就是这个结点

lsize>

k）

returnLocate_BlcTree（T->

lchild,k）;

//在左子树中寻找

elsereturnLocate_BlcTree（T->

rchild,k-T->

lsize）;

//在右子树中寻找,注意要修改k的值

}//Locate_BlcTree

9.41

enum{LEAF,BRANCH}tag;

//结点类型标识

intkeynum;

BPLinkparent;

//双亲指针

intkey[MAXCHILD];

//关键字

union{

BPLinkchild[MAXCHILD];

//非叶结点的孩子指针

struct{

rectype*info[MAXCHILD];

//叶子结点的信息指针

BPNode*next;

//指向下一个叶子结点的链接

}leaf;

}

}BPNode,*BPLink,*BPTree;

//B+树及其结点类型

StatusBPTree_Search（BPTreeT,intkey,BPNode*ptr,intpos）//B+树中按关键字随机查找的算法,返回包含关键字的叶子结点的指针ptr以及关键字在叶子结点中的位置pos

while（p.tag==BRANCH）//沿分支向下查找

for（i=0;

i<

keynum&

key[i];

//确定关键字所在子树

if（i==p->

keynum）returnERROR;

//关键字太大

child[i];

key!

=p->

//在叶子结点中查找

//找不到关键字

pos=i;

}//BPTree_Search 

9.42

voidTrieTree_Insert_Key（TrieTree&

T,StringTypekey）//在Trie树T中插入字符串key,StringType的结构见第四章

q=（TrieNode*）malloc（sizeof（TrieNode））;

kind=LEAF;

lf.k=key;

//建叶子结点

klen=key[0];

i=1;

=klen&

bh.ptr[ord（key[i]）]）

bh.ptr[ord（key[i]）];

i++;

}//自上而下查找

kind==BRANCH）//如果最后落到分支结点（无同义词）:

bh.ptr[o