查找算法

查找

1．线性查找

int Search_seq(int k)

{

int i=0;

while(i

i++;

}

return i;

}

性能：O(n)

2。二分查找

//非递归算法

int TwoFind()

{

int low=0,high=n-1;

int temp;

while(low<=high)

{

temp=(low+high)/2;

if(k==R[temp])

{

return temp;

}

else if(k

{

high=temp-1;

}

else

{

low=temp+1;

}

}

return -1;

}

//递归算法

int TwoFind(int low,int high)

{

int temp;

temp=(low+high)/2;

if(low<=high)

{

if(k==R[temp])

{

return temp;

}

if(k

{

return TwoFind(low,temp-1);

}

else

{

return TwoFind(temp+1,high);

}

}

return -1;

}

性能：T(n)=O(log2n),与二叉树的效率一样

3．树表查找，二叉排序树

二叉排序树：

（1）若它的左子树非空，则左子树上所有结点的值均小于根结点的值。

（2）若它的右子树非空，则右子树上所有结点的值均大于根结点的值。

（3）左、右子树皆是二叉排序树

1).递归查找

BitTree fing(BitTree t,TelemType e)

{

P=t;

While(p!=NULL)

{

If(e==p->data)

{

Return p ;

}

Else if(e>p->data)

{

p=p->left;

}

Else

{

P=p->right;

}

}

Return NULL ;

}

BitTree fing(BitTree t,TelemType e)

{

P=t;

if(p!=NULL)

{

If(e==p->data)

{

Return p ;

}

Else if(e>p->data)

{

Return find(p->left ,e);

}

Else

{

Return find(p->right,e);

}

}

Return NULL ;

}

时间性能；

最好情况：二叉排序树各结点分布均匀

ASL=O(log2n)

最坏情况：ASL=O(n)

二叉排序树的查找效率介于顺序查找和二分查找之间

多级索引结构二叉排序树

适用于小型文件的内部查找，一次I/O就能把索引信息全部调入内存。

问题：但当索引信息量庞大时，采用这种结构会大大增加I/O操作的次数，导致查找效率降低。

4．B-树

一棵m阶的B-树满足下列条件：

（1）每个结点最多m个孩子。

（2）除根结点和叶子结点外，其它每个结点至少有?m/2?个孩子。

（3）根结点至少有两个孩子。

（4）所有的叶子结点在同一层，且不包含任何关键字信息。（5）有k个孩子的分支结点包含k-1个关键字。

5．B+树VSAM文件索引

一棵m阶的B-树满足下列条件：

（1）每个结点最多m个孩子。

（2）除根结点和叶子结点外，其它每个结点至少有?m/2?个孩子。

（3）根结点至少有两个孩子。

（4）所有的叶子结点在同一层，且包含了所有关键字信息。（5）有k个孩子的分支结点包含k个关键字。

B-树和B+数的差别在于：

（1）有n棵子树的节点中含有n个关键字

（2）所有叶子节点中包含了全部关键字的信息，及指向含这些关键字记录的指针且叶子节点本身依关键字的大小而大顺序链接

（3）所有非终端节点可以看成是索引部分，节点中仅含有其字树（根节点）中的最大或最小关键字

6．哈希查找

问题的提出：线性表和树表的查找都是通过各个记录的关键字与给定值进行大量比较来实现的，记录的存储位置是由比较次数来确定的。

哈希方法：在记录的存储位置与其关键字之间建立一个确定的对应函数关系Hash( )，使每个关键字与存储位置建立

一个对应关系：

Address＝Hash ( Rec.key )

在查找时, 先对记录的关键字进行函数计算,把函数值当做记录的存储位置,直接进行查找。若关键字相等, 则查找成功。在存放记录时, 依函数计算的存储位置存放。

查找效率不依赖于n，查找效率非常快，很多能达到O(1)，查找的效率是α（装填因子）的函数，而不是n的函数。因此不管n 多大都可以找到一个合适的装填因子以便将平均查找长度限定在一个范围内。

解决冲突方法之一-——开放定址法

基本思想：

在哈希中建立一个地址探查序列，即d1,d2,d3,……。

对于给定值key，计算出哈希地址为d=H(key) 。当发生冲突时，沿此地址探查序列逐个存储单元中查找。

找到与给定的关键字相等，则查找成功；若逐个扫描碰到一个开放地址（即该存储单元为空），则查找失败。

问题1：一般情况下，散列表空间大小要多于记录的个数，虽然浪费一点空间，但换取的查找效率。装填因子α=n/m(n-记录个数，m-散列表空间大小）

设计散列函数要控制值域，α在[0.65~0.9]合适。α越小冲突越小，查找时比较的次数少，但是浪费空间越多，α大冲突越大，查找时比较的次数就可能比较多，但是浪费空间小。

需要的比较次数取决于哈希函数、处理冲突的方法、和哈希表的装填因子。

/*哈希表（开放定址法）的查找*/

int linsrch(hashtable ht[ ], keytype k) {

int d,i=0;

d=k % p; /*计算哈希地址*/ while( i

{

i++;

d=((d+1) % m); /*用线性探查法解决冲突*/ }

return(d); /*ht[d]=0查找失败，否则查找成功*/

}

linsert( keytype s) /*将s插入ht[ ]中*/

{

int d;

d=linsrch(s); /*确定插入的位置*/

if( ht[d]==0 ) ht[d]=s;

else//不等于0的话要么找了一遍了已经存在这个数了printf("error");

}

（2）二次探查法

基本思想：若d=H(key)，则探查序列为

d+12,d-12,d+22,d-22,d+32,d-32,，(表示平方)解决冲突方法之二-——拉链法

基本思想：将所有关键字为同义词的结点链接在同一个单链表中。

typedef struct node

{ int key;

struct node *next;

}chainhash; /*同义词结点的数据类型*/

chainhash *htc[P];

chainhash *chnsrch( keytype k) /*哈希表（链地址法）的查找*/ {

chainhash *q;

int d;

d= k % P; /*计算哈希地址*/

q=htc[d]; /*扫描确定的单链表*/

while( q!=NULL && q->key!=k)

q=q->next;

return(q);

}

linsert( keytype s) /*将s插入ht[ ]中*/

{

chainhash *q;

q= chnsrch (s); /*确定插入的位置*/

if( q==NULL ) q->key=s;

else//不等于0的话要么找了一遍了已经存在这个数了printf("error");

}

一、查找，平均查找长度ASL

二、线性表的查找

顺序查找、二分查找、分块查找

三、树表的查找

二叉排序树、平衡二叉排序树（A VL树）、

B-树、B+树

四、哈希表的查找

哈希函数、装填因子、冲突、同义词

解决冲突的方法：

（1）开放定址法

（2）拉链法