第七章 查找
7.1概述
1.列表:由同一类型的数据元素组成的集合。
关键码:数据元素中的某个数据项,可以标识列表中的一个或一组数据元素。
键值:关键码的值。
主关键码:可以唯一地标识一个记录的关键码。
次关键码:不能唯一地标识一个记录的关键码。
2.查找 :在具有相同类型的记录构成的集合中找出满足给定条件的记录。
静态查找 :不涉及插入和删除操作的查找 。
动态查找 :涉及插入和删除操作的查找。
3. 线性表:适用于静态查找,主要采用顺序查找技术、折半查找技术。
树表:适用于动态查找,主要采用二叉排序树的查找技术。
散列表:静态查找和动态查找均适用,主要采用散列技术。
7.2线性表的查找技术
1.顺序查找
#include
using namespace std;
const int MaxSize = 100;
class LineSearch{
public:
LineSearch(int a[ ], int n); //构造函数
~LineSearch( ) { } //析构函数为空
int SeqSearch(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;
}
int LineSearch :: SeqSearch(int k)
{
i=n;
while (i>0 && data[i]!=k)
i--;
return i;
}
带监视哨的折半查找:将哨兵放在查找方向的尽头处,
免去了在查找过程中每一次比较后都要判断查找位置是否越界,从而提高查找速度。
int LineSearch :: SeqSearch(int k)
{
int i = length; //从数组高端开始比较
data[0] = k; //设置哨兵
while (data[i] != k) //不用判断下标i是否越界
i--;
return i;
}
单链表的顺序查找
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;
}
}
2.折半查找
非递归折半查找
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
}
递归折半查找
int LineSearch :: BinSearch2(int low, int high, int k){
if (low > high)
return 0; //递归的边界条件
else {
int mid = (low + high) / 2;
if (k < data[mid])
return BinSearch2(low, mid-1, k);
else if (k > data[mid])
return BinSearch2(mid+1, high, k);
else
return mid; //查找成功,返回序号
}
}
折半查找判定树
判定树:折半查找的过程可以用二叉树来描述,
树中的每个结点对应有序表中的一个记录,
结点的值为该记录在表中的位置。
通常称这个描述折半查找过程的二叉树为折半查找判定树,简称判定树。
判定树的构造方法:
⑴ 当n=0时,折半查找判定树为空;
⑵ 当n>0时,
折半查找判定树的根结点为mid=(n+1)/2,
根结点的左子树是与有序表r[1] ~ r[mid-1]相对应的折半查找判定树,
根结点的右子树是与r[mid+1] ~ r[n]相对应的折半查找判定树。
7.3树表的查找技术
1.二叉排序树
二叉排序树(也称二叉查找树):或者是一棵空的二叉树,或者是具有下列性质的二叉树:
⑴若它的左子树不空,则左子树上所有结点的值均小于根结点的值;
⑵若它的右子树不空,则右子树上所有结点的值均大于根结点的值;
⑶ 它的左右子树也都是二叉排序树。
注意:中序遍历二叉排序树可以得到一个按关键码有序的序列
#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; //二叉排序树的根指针
};
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;
}
2.平衡二叉树
平衡二叉树:或者是一棵空的二叉排序树,或者是具有下列性质的二叉排序树:
⑴ 根结点的左子树和右子树的深度最多相差1;
⑵ 根结点的左子树和右子树也都是平衡二叉树。
平衡因子:结点的平衡因子是该结点的左子树的深度与右子树的深度之差。
最小不平衡子树:在平衡二叉树的构造过程中,以距离插入结点最近的、且平衡因子的绝对值大于1的结点为根的子树。
在一个平衡二叉排序树上插入一个新结点S时,主要包括以下三步:
(1) 查找应插位置, 同时记录离插入位置最近的可能失衡结点A(A的平衡因子不等于0)。
(2) 插入新结点S, 并修改从A到S路径上各结点的平衡因子。
(3) 根据A、 B的平衡因子, 判断是否失衡以及失衡类型, 并做相应处理。
7.3 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树是高平衡的。
7.4散列表的查找技术
散列函数的构造:直接定址法 、除留余数法、数字分析法、平方取中法、折叠法(分段叠加法)
冲突处理方法:开放定址法、、链地址法、建立公共溢出区
散列函数的构造
1.直接定址法:散列函数是关键码的线性函数,即:H(key) = a ´ key + b (a,b为常数)
2.保留余数法:散列函数为:H(key)=key mod p
3.数字分析法:根据关键码在各个位上的分布情况,选取分布比较均匀的若干位组成散列地址。
4.平方取中法:对关键码平方后,按散列表大小,取中间的若干位作为散列地址(平方后截取)。
5.折叠法:将关键码从左到右分割成位数相等的几部分,将这几部分叠加求和,取后几位作为散列地址。
冲突处理方法
1.闭散列方法
(1)线性探测法:当发生冲突时,从冲突位置的下一个位置起,依次寻找空的散列地址。
对于键值key,设H(key)=d,闭散列表的长度为m,则发生冲突时,寻找下一个散列地址的公式为:
Hi=(H(key)+di) % m (di=1,2,…,m-1)
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; //查找不成功时插入
}
(2)二次探测法
当发生冲突时,寻找下一个散列地址的公式为:
Hi=(H(key)+di)% m
(di=12,-12,22,-22,…,q2,-q2且q≤m/2)
(3)随机探测法
当发生冲突时,下一个散列地址的位移量是一个随机数列,即寻找下一个散列地址的公式为:
Hi=(H(key)+di)% m
(di是一个随机数列,i=1,2,……,m-1)
2.开散列法
(1)拉链法
基本思想:将所有散列地址相同的记录,即所有同义词的记录存储在一个单链表中(称为同义词子表),在散列表中存储的是所有同义词子表的头指针。
Node<int> *HashSearch2(Node<int> *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<int>; q->data=k;
q->next= ht[j];
ht[j]=q;
}
}
3.建立公共溢出区
基本思想:
散列表包含基本表和溢出表两部分(通常溢出表和基本表的大小相同),
将发生冲突的记录存储在溢出表中。
查找时,对给定值通过散列函数计算散列地址,先与基本表的相应单元进行比较,若相等,则查找成功;否则,再到溢出表中进行顺序查找。