数据结构——查找知识总结
一、查找的基本概念
列表：由同一类型的数据元素组成的集合。
关键码：数据元素中的某个数据项，可以标识列表中的一个或一组数据元素。
键值：关键码的值。
主关键码：可以唯一地标识一个记录的关键码。
次关键码：不能唯一地标识一个记录的关键码。
查找 ：在具有相同类型的记录构成的集合中找出满足给定条件的记录。
查找的结果 ：若在查找集合中找到了与给定值相匹配的记录，则称查找成功；否则，称查找失败。
静态查找 ：不涉及插入和删除操作的查找 。
动态查找 ：涉及插入和删除操作的查找。
静态查找适用于：查找集合一经生成，便只对其进行查找，而不进行插入和删除操作; 或经过一段时间的查找之后，集中地进行插入和删除等修改操作；
动态查找适用于：查找与插入和删除操作在同一个阶段进行，例如当查找成功时，要删除查找到的记录，当查找不成功时，要插入被查找的记录。
查找结构 ：面向查找操作的数据结构 ，即查找基于的数据结构。
线性表：适用于静态查找，主要采用顺序查找技术、折半查找技术。
树表：适用于动态查找，主要采用二叉排序树的查找技术。
散列表：静态查找和动态查找均适用，主要采用散列技术。
平均查找长度：将查找算法进行的关键码的比较次数的数学期望值定义为平均查找长度。
其中：n：问题规模，查找集合中的记录个数；
pi：查找第i个记录的概率；
ci：查找第i个记录所需的关键码的比较次数。
二、查找
1、顺序查找
普通的顺序查找方法
带监视哨的顺序查找方法
2、折半查找
折半查找的判定树
1、顺序查找 （线性查找）
基本思想：
从线性表的一端向另一端逐个将关键码与给定值进行比较，
若相等，则查找成功，给出该记录在表中的位置；
若整个表检测完仍未找到与给定值相等的关键码，则查找失败，给出失败信息。
int LineSearch :: SeqSearch(int k)
{
i=n;
while (i>0 && data[i]!=k)
i--;
return i;
}
2、改进的顺序查找
基本思想：设置“哨兵”。
哨兵就是待查值，
将哨兵放在查找方向的尽头处，
免去了在查找过程中每一次比较后都要判断查找位置是否越界，从而提高查找速度。
int LineSearch :: SeqSearch(int k)
{
int i = length; //从数组高端开始比较
data[0] = k; //设置哨兵
while (data[i] != k) //不用判断下标i是否越界
i--;
return i;
}
3、顺序查找的性能-不成功
int LineSearch :: SeqSearch(int k)
{
int i = length; //从数组高端开始比较
data[0] = k; //设置哨兵
while (data[i] != k) //不用判断下标i是否越界
i--;
return i;
}
4、单链表的顺序查找
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<<“查找失败，比较的次数为:"<
return 0;
} else{
cout<<“\n”<<“查找成功，比较的次数为:"<
return j;
}
}
5、顺序查找的优点：
算法简单而且使用面广。
顺序查找的缺点：
平均查找长度较大，特别是当待查找集合中元素较多时，查找效率较低。
6、折半查找
适用条件：
基本思想：
在有序表中（low, high,low<=high），
取中间记录作为比较对象，
若给定值与中间记录的关键码相等，则查找成功；
若给定值小于中间记录的关键码，则在中间记录的左半区继续查找；
若给定值大于中间记录的关键码，则在中间记录的右半区继续查找。
不断重复上述过程，直到查找成功，或所查找的区域无记录，查找失败。
int LineSearch :: BinSearch1(int k){
int mid, low = 1, high = length; //初始查找区间是[1, n]
while (low <= high) {//当区间存在时
mid = (low + high) / 2;
if (k < data[mid])
high = mid - 1;
else if (k > data[mid])
low = mid + 1;
else
return mid; //查找成功，返回元素序号
}
return 0; //查找失败，返回0
}
三、树
1、判定树的性质
任意结点的左右子树中结点个数最多相差1
任意结点的左右子树的高度最多相差1
任意两个叶子所处的层次最多相差1
2、折半查找判定树
判定树：折半查找的过程可以用二叉树来描述，
树中的每个结点对应有序表中的一个记录，
结点的值为该记录在表中的位置。
通常称这个描述折半查找过程的二叉树为折半查找判定树，简称判定树。
⑴ 当n=0时，折半查找判定树为空；
⑵ 当n＞0时，
折半查找判定树的根结点为mid=(n+1)/2，
根结点的左子树是与有序表r[1] ~ r[mid-1]相对应的折半查找判定树，
根结点的右子树是与r[mid+1] ~ r[n]相对应的折半查找判定树。
任意两棵折半查找判定树，若它们的结点个数相同，则它们的结构完全相同
具有n个结点的折半查找树的高度为
具有n个结点的折半查找判定树的深度为
查找成功：在表中查找任一记录的过程，即是折半查找判定树中从根结点到该记录结点的路径，和给定值的比较次数等于该记录结点在树中的层数。
查找成功时的平均查找长度ASL：
查找不成功：
查找失败的过程就是走了一条从根结点到外部结点的路径，
和给定值进行的关键码的比较次数等于该路径上内部结点的个数（失败情况下的平均查找长度等于树的高度）。
3、二叉排序树的性质
二叉排序树（也称二叉查找树）：或者是一棵空的二叉树，或者是具有下列性质的二叉树：
⑴若它的左子树不空，则左子树上所有结点的值均小于根结点的值；
⑵若它的右子树不空，则右子树上所有结点的值均大于根结点的值；
⑶ 它的左右子树也都是二叉排序树。
中序遍历二叉排序树可以得到一个按关键码有序的序列
#include
using namespace std;
template
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; //二叉排序树的根指针
};
4、二叉排序树的插入
void InsertBST(BiNode
分析：若二叉排序树为空树，则新插入的结点为新的根结点；否则，新插入的结点必为一个新的叶子结点，其插入位置由查找过程得到。
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;
}
5、二叉排序树的构造
BiSortTree::BiSortTree(int a[ ], int n)
{
root = NULL;
for (int i = 0; i < n; i++)
root = InsertBST(root, a[i]);
}
6、二叉排序树的删除
在二叉排序树上删除某个结点之后，仍然保持二叉排序树的特性。
分三种情况讨论：
void BiSortTree::DeleteBST(BiNode *p, BiNode *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;
} //左右子树均不空的情况处理完毕
}
7、二叉排序树的查找
在二叉排序树中查找给定值k的过程是：
⑴ 若root是空树，则查找失败；
⑵ 若k＝root->data，则查找成功；否则
⑶ 若k＜root->data，则在root的左子树上查找；否则
⑷ 在root的右子树上查找。
上述过程一直持续到k被找到或者待查找的子树为空，如果待查找的子树为空，则查找失败。
二叉排序树的查找效率在于只需查找二个子树之一。
BiNode *BiSortTree::SearchBST(BiNode *root, int k)
{
if (root==NULL)
return NULL；
else if (root->data==k)
return root;
else if (kdata)
return SearchBST(root->lchild, k);
else
return SearchBST(root->rchild, k);
}
8、平衡二叉树（AVL树）
平衡二叉树：或者是一棵空的二叉排序树，或者是具有下列性质的二叉排序树：
⑴ 根结点的左子树和右子树的深度最多相差1;
⑵ 根结点的左子树和右子树也都是平衡二叉树。
平衡因子：结点的平衡因子是该结点的左子树的深度与右子树的深度之差。
最小不平衡子树：在平衡二叉树的构造过程中，以距离插入结点最近的、且平衡因子的绝对值大于1的结点为根的子树。
基本思想：
在构造二叉排序树的过程中，每插入一个结点时，首先检查是否因插入而破坏了树的平衡性，
若是，
则找出最小不平衡子树，
在保持二叉排序树特性的前提下，调整最小不平衡子树中各结点之间的链接关系，进行相应的旋转，使之成为新的平衡子树。
设结点A为最小不平衡子树的根结点，对该子树进行平衡调整归纳起来有以下四种情况：
1. LL型
2. RR型
3. LR型
4. RL型
综上所述， 在一个平衡二叉排序树上插入一个新结点S时，主要包括以下三步：
（1） 查找应插位置， 同时记录离插入位置最近的可能失衡结点A（A的平衡因子不等于0）。
（2） 插入新结点S， 并修改从A到S路径上各结点的平衡因子。
（3） 根据A、 B的平衡因子， 判断是否失衡以及失衡类型， 并做相应处理。
四、B+树
1、B+树的结构定义
B+树是B-树的变体，也是一种多路搜索树：
m阶B+树的结构定义如下：
(1)每个结点至多有m个子结点；
(2)每个结点(除根外)至少有ceiling(m/2)个子结点；
(3)根结点至少有两个子结点；
(4)有k个子结点的结点必有k个关键码。
m阶B＋树：是满足下列特性的树：
⑴ 含有m个关键码，每一个关键码对应一棵子树。
⑵ 关键码Ki是它所对应的子树的根结点中的最大（或最小）关键码。
⑶ 所有终端结点中包含了全部关键码信息，以及指向关键码记录的指针。
⑷ 所有终端结点按关键码的大小链在一起，形成单链表，并设置头指针。
2、B+树的查找
查找应该到叶结点层
在上层已找到待查的关键码，并不停止
而是继续沿指针向下一直查到叶结点层的这个关键码
B+树的叶结点一般链接起来，形成一个双链表
适合顺序检索（范围检索）
3、B-树和B+树
特点
对于阶数相同的两棵树，每个节点所包含的分支数的定义相同（不能少于m/2,不能多于m)
每个节点所包含的关键字的个数不同
B-树中，关键字不重复出现；B+树中，叶子节点存放所有的关键字，内部结点存储着其后继节点中最大的关键字
插入操作都会引起节点的分裂
删除操作都会引起节点的合并
B-树适用于随机检索；B+树支持随机和顺序检索
五、散列表（hash）的查找技术
散列函数的构造
直接定址法
除留余数法
数字分析法
平方取中法
折叠法（分段叠加法）
冲突处理方法
开放定址法
链地址法
建立公共溢出区
1、概 述
散列的基本思想：在记录的存储地址和它的关键码之间建立一个确定的对应关系。这样，不经过比较，一次读取就能得到所查元素的查找方法。
散列表：采用散列技术将记录存储在一块连续的存储空间中，这块连续的存储空间称为散列表。
散列函数：将关键码映射为散列表中适当存储位置的函数。
散列地址：由散列函数所得的存储位置址 。
散列既是一种查找技术，也是一种存储技术。
散列只是通过记录的关键码定位该记录，没有完整地表达记录之间的逻辑关系，所以，散列主要是面向查找的存储结构。
也不可能找到在某一范围内的记录
散列技术的关键问题：
⑴ 散列函数的设计。如何设计一个简单、均匀、存储利用率高的散列函数。
⑵ 冲突的处理。如何采取合适的处理冲突方法来解决冲突。
冲突：对于两个不同关键码ki≠kj，有H(ki)＝H(kj)，即两个不同的记录需要存放在同一个存储位置,ki和kj相对于H称做同义词。
2、散列函数
设计散列函数一般应遵循以下原则：
⑴ 计算简单。散列函数不应该有很大的计算量，否则会降低查找效率。
⑵ 函数值即散列地址分布均匀。函数值要尽量均匀散布在地址空间，这样才能保证存储空间的有效利用并减少冲突。
1、直接定址法：散列函数是关键码的线性函数，即：H(key) = a ´ key + b （a，b为常数）。
2、除留余数法：散列函数为：H(key)=key mod p 。
一般情况下，选p为小于或等于表长（最好接近表长）的最小素数
除留余数法是一种最简单、也是最常用的构造散列函数的方法，并且不要求事先知道关键码的分布。
3、数字分析法：根据关键码在各个位上的分布情况，选取分布比较均匀的若干位组成散列地址。
适用情况:事先知道关键码的分布，关键码的分布均。
4、平方取中法：对关键码平方后，按散列表大小，取中间的若干位作为散列地址（平方后截取）。
适用情况:事先不知道关键码的分布且关键码的位数不是很大。
5、折叠法：将关键码从左到右分割成位数相等的几部分，将这几部分叠加求和，取后几位作为散列地址。
3、冲突的处理
开散列方法( open hashing，也称为拉链法，separate chaining ，链地址法)
闭散列方法( closed hashing，也称为开地址方法，open addressing ，开放定址法)
建立公共溢出区
1、开放定址法：由关键码得到的散列地址一旦产生了冲突，就去寻找下一个空的散列地址，并将记录存入。
如何寻找下一个空的散列地址?
（1）线性探测法
（2）二次探测法
（3）随机探测法
（4）再hash法
用开放定址法处理冲突得到的散列表叫闭散列表。
2、线性探测法：当发生冲突时，从冲突位置的下一个位置起，依次寻找空的散列地址。
对于键值key，设H(key)=d，闭散列表的长度为m，则发生冲突时，寻找下一个散列地址的公式为：
Hi=(H(key)＋di) % m （di=1，2，…，m-1）
堆积：在处理冲突的过程中出现的非同义词之间对同一个散列地址争夺的现象。
假设给定的值为K，根据所设定的散列函数h，计算出散列地址h (K)
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; //查找不成功时插入
}
3、二次探测法
当发生冲突时，寻找下一个散列地址的公式为：
Hi=(H(key)＋di)% m
（di=12，－12，22，－22，…，q2，－q2且q≤m/2）
4、随机探测法
当发生冲突时，下一个散列地址的位移量是一个随机数列，即寻找下一个散列地址的公式为：
Hi=(H(key)+di)% m
（di是一个随机数列，i=1，2，……，m-1）
5、拉链法（链地址法）
基本思想：将所有散列地址相同的记录，即所有同义词的记录存储在一个单链表中（称为同义词子表），在散列表中存储的是所有同义词子表的头指针。
用拉链法处理冲突构造的散列表叫做开散列表。
设n个记录存储在长度为m的散列表中，则同义词子表的平均长度为n / m。
1. 计算散列地址j；
2. 在第j个同义词子表中顺序查找；
3. 若查找成功，则返回结点的地址；
否则，将待查记录插在第j个同义词子表的表头。
Node *HashSearch2(Node *ht[ ], int m, int k)
{
j=H(k);
p=ht[j];
while (p && p->data!=k)
p=p->next;
if (p->data= =k) return p;
else {
q=new Node; q->data=k;
q->next= ht[j];
ht[j]=q;
}
}
6、公共溢出区
基本思想：
散列表包含基本表和溢出表两部分（通常溢出表和基本表的大小相同），
将发生冲突的记录存储在溢出表中。
查找时，对给定值通过散列函数计算散列地址，先与基本表的相应单元进行比较，若相等，则查找成功；否则，再到溢出表中进行顺序查找。
4、散列表的删除、插入、查找过程
删除
要进行标记，否则影响后面的查找工作
查找
遇到标记后，继续查找
插入
遇到标记，不能直接插入；
否在，会造成重复数据
继续，搜索
查找成功，停止插入
查找失败，进行插入
5、散列查找的性能分析
由于冲突的存在，产生冲突后的查找仍然是给定值与关键码进行比较的过程。
在查找过程中，关键码的比较次数取决于产生冲突的概率。而影响冲突产生的因素有：
（1）散列函数是否均匀
（2）处理冲突的方法
（3）散列表的装载因子
α=表中填入的记录数/表的长度
几种不同处理冲突方法的平均查找长度：
装填因子的作用：
已知一组关键字为（26,36,41,38,44,15,68,12,06,51,25），用链地址法解决冲突。假设装填因子a=0.75，散列函数的形式为H（K）=K MOD P，回答下列问题：
（1） 构造出散列函数；
（2） 计算出等概率情况下查找成功的平均查找长度；
（3） 计算出等概率情况下查找失败的平均查找长度；
手工计算等概率情况下查找成功的平均查找长度公式手工计算等概率情况下查找成功的平均查找长度规则如下
其中Ci为置入每个元素时所需的比较次数。
手工计算在等概率情况下查找不成功的平均查找长度公式手工计算等概率情况下查找不成功的平均查找长度规则如下
其中Ci为函数取值为i时确定查找不成功时的比较次数。
开散列表与闭散列表的比较：
