数据结构 第七章 查找

2022-11-29 14:48:47 浏览数 (1)

7.1 概述

查找的基本概念

列表：由同一类型的数据元素组成的集合。 关键码：数据元素中的某个数据项，可以标识列表中的一个或一组数据元素。 键值：关键码的值。 主关键码：可以唯一地标识一个记录的关键码。 次关键码：不能唯一地标识一个记录的关键码。

查找 ：在具有相同类型的记录构成的集合中找出满足给定条件的记录。 查找的结果 ：若在查找集合中找到了与给定值相匹配的记录，则称查找成功；否则，称查找失败。 静态查找 ：不涉及插入和删除操作的查找 。 动态查找 ：涉及插入和删除操作的查找。 静态查找适用于：查找集合一经生成，便只对其进行查找，而不进行插入和删除操作; 或经过一段时间的查找之后，集中地进行插入和删除等修改操作； 动态查找适用于：查找与插入和删除操作在同一个阶段进行，例如当查找成功时，要删除查找到的记录，当查找不成功时，要插入被查找的记录。

查找结构 ：面向查找操作的数据结构 ，即查找基于的数据结构。

线性表：适用于静态查找，主要采用顺序查找技术、折半查找技术。 树表：适用于动态查找，主要采用二叉排序树的查找技术。 散列表：静态查找和动态查找均适用，主要采用散列技术。

平均查找长度：将查找算法进行的关键码的比较次数的数学期望值定义为平均查找长度。计算公式为：

其中：n：问题规模，查找集合中的记录个数； pi：查找第i个记录的概率； ci：查找第i个记录所需的关键码的比较次数。 结论：ci取决于算法；pi与算法无关，取决于具体应用。如果pi是已知的，则平均查找长度只是问题规模的函数。

代码语言：javascript复制
查找成功的查找长度
查找失败的查找长度
总的查找长度为成功及失败情况下查找长度的均值
通常情况下，查找不成功的概率可以忽略不计

7.2 线性表的查找技术

顺序查找 普通的顺序查找方法 带监视哨的顺序查找方法 折半查找 折半查找的判定树

代码语言：javascript复制
#include 
using namespace std;

const int MaxSize = 100;
class LineSearch{
public:
    LineSearch(int a[ ], int n); //构造函数
   ~LineSearch( ) { } //析构函数为空
    int SeqSearch(int k); //顺序查找
    int BinSearch1(int k); //折半非递归查找
    int BinSearch2(int low, int high, int k); //折半递归查找
private:
    int data[MaxSize]; //查找集合为整型
    int length; //查找集合的元素个数
};

LineSearch :: LineSearch(int a[ ], int n){
    for (int i = 0; i < n; i  )
        data[i 1] = a[i]; //查找集合从下标1开始存放
    length = n;
}

基本思想： 从线性表的一端向另一端逐个将关键码与给定值进行比较， 若相等，则查找成功，给出该记录在表中的位置； 若整个表检测完仍未找到与给定值相等的关键码，则查找失败，给出失败信息。

代码语言：javascript复制
int LineSearch :: SeqSearch(int k)
{   
     i=n;
     while (i>0 && data[i]!=k)
         i--;
     return i;
}

改进的顺序查找 基本思想：设置“哨兵”。 哨兵就是待查值， 将哨兵放在查找方向的尽头处， 免去了在查找过程中每一次比较后都要判断查找位置是否越界，从而提高查找速度。

基本思想：设置“哨兵”。哨兵就是待查值，将它放在查找方向的尽头处，免去了在查找过程中每一次比较后都要判断查找位置是否越界，从而提高查找速度。

代码语言：javascript复制
int LineSearch :: SeqSearch(int k)
{ 
    int i = length;        //从数组高端开始比较
    data[0] = k;           //设置哨兵
    while (data[i] != k) //不用判断下标i是否越界
        i--;
    return i; 
}


int LineSearch :: SeqSearch(int k)
{ 
    int i = length;        //从数组高端开始比较
    data[0] = k;           //设置哨兵
    while (data[i] != k) //不用判断下标i是否越界
        i--;
    return i; 
}

记录每个数据的访问频率， 把访问频率高的数据移向顺序表的右端 可以减少查找成功时所进行的比较次数，提高效率 构造有序的顺序表 减少查找失败时所进行的比较次数，提高查找效率 单链表的顺序查找

代码语言：javascript复制
int LinkSearch::SeqSearch2(Node *first, int k){  
	Node *p;
	int count=0;//记录比较的次数
	p=first->next; 
	int j=1;//记录数据在表中的位置
      while (p &&  p->data != k)
	{p=p->next;	j  ;    count  ;}
	if (!p){
             cout<<“查找失败，比较的次数为:"<<count<<endl; 	
             return 0;
     } else{
	    cout<<“n”<<“查找成功，比较的次数为:"<<count<<endl; 	 
          return j;
	}
}

顺序查找的优点： 算法简单而且使用面广。 对表中记录的存储结构没有任何要求，顺序存储和链接存储均可； 对表中记录的有序性也没有要求，无论记录是否按关键码有序均可。 顺序查找的缺点： 平均查找长度较大，特别是当待查找集合中元素较多时，查找效率较低。

折半查找

适用条件： 线性表中的记录必须按关键码有序； 必须采用顺序存储。

基本思想： 在有序表中（low, high,low<=high）， 取中间记录作为比较对象， 若给定值与中间记录的关键码相等，则查找成功； 若给定值小于中间记录的关键码，则在中间记录的左半区继续查找； 若给定值大于中间记录的关键码，则在中间记录的右半区继续查找。 不断重复上述过程，直到查找成功，或所查找的区域无记录，查找失败。

判定树：折半查找的过程可以用二叉树来描述， 树中的每个结点对应有序表中的一个记录， 结点的值为该记录在表中的位置。 通常称这个描述折半查找过程的二叉树为折半查找判定树，简称判定树。

⑴ 当n=0时，折半查找判定树为空； ⑵ 当n＞0时， 折半查找判定树的根结点为mid=(n 1)/2， 根结点的左子树是与有序表r[1] ~ r[mid-1]相对应的折半查找判定树， 根结点的右子树是与r[mid 1] ~ r[n]相对应的折半查找判定树。

任意两棵折半查找判定树，若它们的结点个数相同，则它们的结构完全相同 具有n个结点的折半查找树的高度为

查找成功：在表中查找任一记录的过程，即是折半查找判定树中从根结点到该记录结点的路径，和给定值的比较次数等于该记录结点在树中的层数。

查找成功时的平均查找长度ASL：

查找不成功： 查找失败的过程就是走了一条从根结点到外部结点的路径， 和给定值进行的关键码的比较次数等于该路径上内部结点的个数（失败情况下的平均查找长度等于树的高度）。

线性表查找的特点 线性表查找是静态的查找，要在线性表上进行动态查找，存在以下的问题 无序顺序表上进行动态查找，插入操作简单，但查找的复杂性高 有序顺序表上进行动态查找，查找的时间复杂性好，但是插入操作时间复杂性高 单链表上进行动态查找，插入操作简单，但查找操作复杂性高 解决办法： 采用二叉树这种数据结构，实现动态查找

二叉排序树（也称二叉查找树）：或者是一棵空的二叉树，或者是具有下列性质的二叉树： ⑴若它的左子树不空，则左子树上所有结点的值均小于根结点的值； ⑵若它的右子树不空，则右子树上所有结点的值均大于根结点的值； ⑶ 它的左右子树也都是二叉排序树。

代码语言：javascript复制
//中序遍历二叉排序树可以得到一个按关键码有序的序列 
#include <iostream>
using namespace std;
template <class DataType> 
struct BiNode{    DataType data;     BiNode *lchild, *rchild;  };
class BiSortTree {
public:
    BiSortTree(int a[ ], int n); //建立查找集合a[n]的二叉排序树
     ~ BiSortTree( ){ Release(root); } //析构函数，同二叉链表的析构函数
    void InOrder( ){InOrder(root);} //中序遍历二叉树
    BiNode *InsertBST(int x) {return InsertBST(root, x);} //插入记录x
    BiNode *SearchBST(int k) {return SearchBST(root, k);} //查找值为k的结点
    void DeleteBST(BiNode *p, BiNode *f ); //删除f的左孩子p
private:
   void Release(BiNode *bt);
   BiNode *InsertBST(BiNode *bt , int x);  
   BiNode *SearchBST(BiNode *bt, int k); 
   void InOrder(BiNode *bt); //中序遍历函数调用
   BiNode *root; //二叉排序树的根指针
};

二叉排序树的插入

代码语言：javascript复制
void InsertBST(BiNode<int> * & root , BiNode<int> *s);

分析：若二叉排序树为空树，则新插入的结点为新的根结点；否则，新插入的结点必为一个新的叶子结点，其插入位置由查找过程得到。

二叉排序树的插入算法

代码语言：javascript复制
void BiSortTree :: InOrder(BiNode *bt) 
{
if (bt == nullptr) return; //递归调用的结束条件
else {
InOrder(bt->lchild); //前序递归遍历bt的左子树
cout << bt->data << "	"; //访问根结点bt的数据域
InOrder(bt->rchild); //前序递归遍历bt的右子树 
}
}

BiNode * BiSortTree :: SearchBST(BiNode *bt, int k)
{
if (bt == nullptr) return nullptr;
if (bt->data == k) return bt;
else if (bt->data > k) return SearchBST(bt->lchild, k);
else return SearchBST(bt->rchild, k);
}

BiNode *BiSortTree::InsertBST(BiNode *bt, int x)
{
if (bt == nullptr) { //找到插入位置
BiNode *s = new BiNode; 
s->data = x;
s->lchild = nullptr; s->rchild = nullptr;
bt = s;
return bt;
}
else if (bt->data > x) bt->lchild = InsertBST(bt->lchild, x);
else bt->rchild = InsertBST(bt->rchild, x);
}

BiSortTree::BiSortTree(int a[ ], int n)
{
root = nullptr;
for (int i = 0; i < n; i  )
root = InsertBST(root, a[i]);
}

void BiSortTree::DeleteBST(BiNode *p, BiNode *f ) 
{
if ((p->lchild == nullptr) && (p->rchild == nullptr)) { //p为叶子
f->lchild = nullptr; delete p; return;
}
if (p->rchild == nullptr) { //p只有左子树
f->lchild = p->lchild; delete p; return;
}
if (p->lchild == nullptr) { //p只有右子树
f->lchild = p->rchild; delete p; return;
}
BiNode *par = p, *s = p->rchild; //p的左右子树均不空
while (s->lchild != nullptr) //查找最左下结点
{
par = s;
s = s->lchild;
}
p->data = s->data;
if (par == p) par->rchild = s->rchild; //特殊情况，p的右孩子无左子树
else par->lchild = s->rchild; 
delete s;
} 

void BiSortTree :: Release(BiNode *bt)
{
if (bt == nullptr) return;
else{
Release(bt->lchild); //释放左子树
Release(bt->rchild); //释放右子树
delete bt; //释放根结点
}
}

int main( )
{
BiNode *p = nullptr;
int arr[10] = {7 ,2, 3, 10, 5, 6, 1, 8, 9, 4};
BiSortTree B{arr,10}; 
B.InOrder();
int key;
cout << "请输入查找的元素值";
cin >> key; 
p = B.SearchBST(key);
if (p != nullptr)
cout << p->data << endl;
else 
cout << "查找失败" << endl;
system("pause");
return 0;

}
BiNode *BiSortTree::InsertBST(BiNode *bt, int x)
{
	if (bt == NULL) { //找到插入位置
		BiNode *s = new BiNode; 
		s->data = x;
		s->lchild = NULL;
		s->rchild = NULL;
		bt = s;
		return bt;
	}
	else if (bt->data > x) 
		bt->lchild = InsertBST(bt->lchild, x);
	else
		bt->rchild = InsertBST(bt->rchild, x);
}

二叉排序树的删除算法——伪代码

代码语言：javascript复制
1.若结点p是叶子，则直接删除结点p；
2. 若结点p只有左子树，则只需重接p的左子树；
    若结点p只有右子树，则只需重接p的右子树； 
3. 若结点p的左右子树均不空，则
   3.1 查找结点p的右子树上的最左下结点s及s双亲结点par；
   3.2 将结点s数据域替换到被删结点p的数据域；
   3.3 若结点p的右孩子无左子树，
         则将s的右子树接到par的右子树上；
         否则，将s的右子树接到结点par的左子树上； 
   3.4 删除结点s；
代码语言：javascript复制
void BiSortTree::DeleteBST(BiNode<int> *p, BiNode<int> *f ) {
	 if (!p->lchild && !p->rchild) 	{   
              if(f->child==p)        f->lchild= NULL;  
              else  f->lchild= NULL; 
              delete p;
	  }
	 else if (!p->rchild) {     //p只有左子树
             if(f->child==p)   f->lchild=p->lchild;
             else f->rchild=p->lchild;
	               delete p;
	 }
	 else if (!p->lchild) {   //p只有右子树
		 if(f->child==p)  f->lchild=p->rchild;
		 else f->rchild=p->rchild;
            delete p;
        	}
        
else {   //左右子树均不空
             par=p;  s=p->rchild;  
             while (s->lchild!=NULL)   //查找最左下结点
             {
               par=s;
               s=s->lchild;
             }
             p->data=s->data;
             if (par==p) p->rchild=s->rchild;  //处理特殊情况
                 else par->lchild=s->rchild;    //一般情况
             delete s;
           } //左右子树均不空的情况处理完毕
 }

二叉排序树的查找 ⑴ 若root是空树，则查找失败； ⑵ 若k＝root->data，则查找成功；否则 ⑶ 若k＜root->data，则在root的左子树上查找；否则 ⑷ 在root的右子树上查找。 上述过程一直持续到k被找到或者待查找的子树为空，如果待查找的子树为空，则查找失败。 二叉排序树的查找效率在于只需查找二个子树之一。

代码语言：javascript复制
BiNode *BiSortTree::SearchBST(BiNode<int> *root, int k)
{
    if (root==NULL)
    return NULL；
    else if (root->data==k) 
              return root;
    else if (k<root->data) 
              return SearchBST(root->lchild, k);
    else 
	         return SearchBST(root->rchild, k);
}

平衡二叉树：或者是一棵空的二叉排序树，或者是具有下列性质的二叉排序树： ⑴ 根结点的左子树和右子树的深度最多相差1; ⑵ 根结点的左子树和右子树也都是平衡二叉树。 平衡因子：结点的平衡因子是该结点的左子树的深度与右子树的深度之差。 最小不平衡子树：在平衡二叉树的构造过程中，以距离插入结点最近的、且平衡因子的绝对值大于1的结点为根的子树。 设结点A为最小不平衡子树的根结点，对该子树进行平衡调整归纳起来有以下四种情况：

  1. LL型
  2. RR型
  3. LR型
  4. RL型

B－树

1972年R.Bayer和E.M.McCreight提出了一种称之为B-树的多路平衡查找树。它适合在磁盘等直接存取设备上组织动态的查找表。 m阶B－树：是满足下列特性的树： (1) 树中每个结点至多有m棵子树； (2) 若根结点不是终端结点，则至少有两棵子树； (3) 除根结点外，其他非终端结点至少有m/2 棵子树； (4)所有非终端结点都包含以下数据： （n，A0，K1，A1，K2，…，Kn，An） 其中，n（m/2 1≤n≤m 1）为关键码的个数； Ki（1≤i≤n）为关键码，且Ki＜Ki 1（1≤i≤n-1）； Ai（0≤i≤n）为指向子树根结点的指针，且指针Ai所指子树中所有结点的关键码均小于Ki 1大于Ki。 (5)所有叶子结点都在同一层上，B树是高平衡的。

m阶B＋树：是满足下列特性的树： ⑴ 含有m个关键码，每一个关键码对应一棵子树。 ⑵ 关键码Ki是它所对应的子树的根结点中的最大（或最小）关键码。 ⑶ 所有终端结点中包含了全部关键码信息，以及指向关键码记录的指针。 ⑷ 所有终端结点按关键码的大小链在一起，形成单链表，并设置头指针。

散列表（hash）的查找技术

散列函数的构造 直接定址法 除留余数法 数字分析法 平方取中法 折叠法（分段叠加法） 冲突处理方法 开放定址法 链地址法 建立公共溢出区

散列的基本思想：在记录的存储地址和它的关键码之间建立一个确定的对应关系。这样，不经过比较，一次读取就能得到所查元素的查找方法。 散列表：采用散列技术将记录存储在一块连续的存储空间中，这块连续的存储空间称为散列表。 散列函数：将关键码映射为散列表中适当存储位置的函数。 散列地址：由散列函数所得的存储位置址 。 冲突：对于两个不同关键码ki≠kj，有H(ki)＝H(kj)，即两个不同的记录需要存放在同一个存储位置,ki和kj相对于H称做同义词。 直接定址法 散列函数是关键码的线性函数，即： H(key) = a * key b （a，b为常数） 除留余数法 H(key)=key mod p 一般情况下，选p为小于或等于表长（最好接近表长）的最小素数 ……

开散列方法( open hashing，也称为拉链法，separate chaining ，链地址法) 闭散列方法( closed hashing，也称为开地址方法，open addressing ，开放定址法) 建立公共溢出区

线性探测法 当发生冲突时，从冲突位置的下一个位置起，依次寻找空的散列地址。 对于键值key，设H(key)=d，闭散列表的长度为m，则发生冲突时，寻找下一个散列地址的公式为： Hi=(H(key)＋di) % m （di=1，2，…，m-1）

假设给定的值为K，根据所设定的散列函数h，计算出散列地址h (K) 否则将该地址中的值与K比较，若相等则检索成功,算法结束 否则，按建表时设定的处理冲突方法查找探查序列的下一个地址，如此反复下去 直到某个地址空间未被占用（查找不成功，可以插入），算法结束 或者关键码比较相等（有重复记录，不需要插入）为止，算法结束 如果探测完整个hash表，都没有进行插入或查找失败，则抛出空间异常（hash表容量不足）

代码语言：javascript复制
int HashSearch1(int ht[ ], int m, int k) 
{
     j=H(k);  
     if (ht[j]==k) return j;   //没有发生冲突，比较一次查找成功
     i=(j 1) % m;
     while (ht[i]!=Empty && i!=j)  
     {
         if (ht[i]==k) return i;  //发生冲突，比较若干次查找成功
         i=(i 1) % m;    //向后探测一个位置
     }
     if (i==j) throw "溢出";
     else ht[i]=k;   //查找不成功时插入
}

处理冲突的方法——拉链法（链地址法） 基本思想：将所有散列地址相同的记录，即所有同义词的记录存储在一个单链表中（称为同义词子表），在散列表中存储的是所有同义词子表的头指针。

用拉链法处理冲突构造的散列表叫做开散列表。

设n个记录存储在长度为m的散列表中，则同义词子表的平均长度为n / m。

几种不同处理冲突方法的平均查找长度

装填因子 已知一组关键字为（26,36,41,38,44,15,68,12,06,51,25），用链地址法解决冲突。假设装填因子a=0.75，散列函数的形式为H（K）=K MOD P，回答下列问题： （1） 构造出散列函数； （2） 计算出等概率情况下查找成功的平均查找长度； （3） 计算出等概率情况下查找失败的平均查找长度；

由α=0.75， 表长m=11/0.75=15 散列函数 H（k）=k MOD 13（p取小于等于表长的最大素数）

开散列表与闭散列表的比较

二叉树 存储 编程算法

0 人点赞