文章目录
背景介绍
最近重新看了一遍查找的相关算法，在这里进行一些总结。另外提醒读者，看文章时，一定首重思路，搞清楚思路，至于代码，不过是思路的具体化而已。
查找
定义：查找就是根据某个给定的值，在查找表中确定一个其关键字等于给定的值的数据元素或记录。
概念解析
查找表：同一类型的数据元素构成的集合。
关键字：是数据元素中某个数据项的值，可以标志一个数据元素（记录）或某个数据项，其中此关键字可以唯一标志一个数据元素的，称为主关键字，可以标志多个数据元素的，称为次关键字。
查找表的分类：按查找的操作方式可以分为两大种，静态查找表和动态查找表。
静态查找表：只做查找操作，主要操作为：
- 查找某个特定的数据元素是否在查找表中
- 查找特点的数据元素及其各种属性
动态查找表：不仅做查找操作，并且在查找过程中对某个数据元素进行插入或删除。
主要操作为：
- 在查找中进行插入
- 在查找中进行删除
PS：为了获得较高的查找效率，有时我们不得不改变查找表的结构，将查找表变成表，树等结构。
顺序表查找
定义：又称为线性查找，从查找表的第一个数据元素开始，逐个跟给定值比较，若相同，则查找成功，输出数据元素在查找表的下标，若不相同，则与查表的下一个数据元素比较，重复该操作，直到查找表的最后一个元素。
代码如下
int Sequential_Search(int *a,int n,int key)
{
int i;
for(i=1;i<=n;i++)
{
if (a[i]==key)
return i;
}
return 0;
}
优化：可以设置一个哨兵，减少运行代码
/* 有哨兵顺序查找 */
int Sequential_Search2(int *a,int n,int key)
{
int i;
a[0]=key;
i=n;
while(a[i]!=key)
{
i--;
}
return i;
}
折半查找
前提：查找表为线性表，且有序排列。
定义：又称为二分查找，将给定值与有序表中中间值做对比，若相同，则查找成功，若小于中间值，则在有序表左区域查找，若大于中间值，则在有序表有区域查找，重复此操作，直到查找成功或查找区域无元素。
中间值：mid=low+（high-low）/2；
结构代码如下：
/* 折半查找 */
int Binary_Search(int *a,int n,int key)
{
int low,high,mid;
low=1; /* 定义最低下标为记录首位 */
high=n; /* 定义最高下标为记录末位 */
while(low<=high)
{
mid=(low+high)/2; /* 折半 */
if (key<a[mid]) /* 若查找值比中值小 */
high=mid-1; /* 最高下标调整到中位下标小一位 */
else if (key>a[mid])/* 若查找值比中值大 */
low=mid+1; /* 最低下标调整到中位下标大一位 */
else
{
return mid; /* 若相等则说明mid即为查找到的位置 */
}
}
return 0;
}
插值查找
定义：插值查找类似于折半查找，在折半查找中，将查找表根据中间值mid将查找区域一分为二，分为大概长度相同的两部分区域，而插值查找则是根据给定值与查找区域的最大最小值的比例决定mid，再根据mid将查找区域划分为比例不同的两部分区域，重复操作，适合表较长，且关键字分布较为均匀的查找表。
中间值：mid=low+[（key-a[low]）/(a[high]-a[low])]*(high-low)
代码如下：
/* 插值查找 */
int Interpolation_Search(int *a,int n,int key)
{
int low,high,mid;
low=1; /* 定义最低下标为记录首位 */
high=n; /* 定义最高下标为记录末位 */
while(low<=high)
{
mid=low+ (high-low)*(key-a[low])/(a[high]-a[low]); /* 插值 */
if (key<a[mid]) /* 若查找值比插值小 */
high=mid-1; /* 最高下标调整到插值下标小一位 */
else if (key>a[mid])/* 若查找值比插值大 */
low=mid+1; /* 最低下标调整到插值下标大一位 */
else
return mid; /* 若相等则说明mid即为查找到的位置 */
}
return 0;
}
斐波那契查找
定义：类似于折半查找，mid根据黄金分割比例设置
如图：
中间值：mid=low+F[k-1]-1;
PS：当数组元素不足F[k]-1位时，将数组扩大到F[k]-1位，增加的位用数组元素最后一位的数值补全。
代码如下：
/* 斐波那契查找 */
int Fibonacci_Search(int *a,int n,int key)
{
int low,high,mid,i,k=0;
low=0; /* 定义最低下标为记录首位 */
high=n-1; /* 定义最高下标为记录末位 */
while(n>F[k]-1)
k++;
for (i=n;i<F[k]-1;i++)
a[i]=a[n-1];
while(low<=high)
{
mid=low+F[k-1]-1;
if (key<a[mid])
{
high=mid-1;
k=k-1;
}
else if (key>a[mid])
{
low=mid+1;
k=k-2;
}
else
{
if (mid<=n)
return mid; /* 若相等则说明mid即为查找到的位置 */
else
return n;
}
}
return 0;
}
PS：F数组应该事先统计好（全局变量）
小结
无论是折半查找，还是插值查找，还是斐波那契查找，都是根据某种比例对有序表进行划分，然后重复操作，时间复杂度都是O(log n)，应根据具体情况具体分析。
线性索引查找
索引：索引是为了提高查找效率而设计的一种数据结构，索引化就是把一个关键字和它对应的数据元素相关联的过程，一个索引由若干个索引项构成，类似数据元素的数据项，一个索引至少包含一个关键字和相应记录的存储位置。
索引按照结构可以分为线性索引、树形索引、多级索引，在这里只介绍线性索引。所谓线性索引就是把索引的集合结构设为线性结构，也叫索引表。
线性索引分类：
- 稠密索引
- 分块索引
- 倒排索引
稠密索引
定义：指在线性索引中，将数据集中每个记录对应一个索引。其中稠密索引的索引表要求索引按照关键字有序排列。
分块索引
定义：将数据集中的记录分为若干块，须满足块间有序的条件（第二块的关键字均大于第一块的最大关键字，以此类推），每个索引包含三个索引项（块的最大关键字，块的数量，块的首行记录）
倒排索引
定义：不是由位置来确实属性值，而是根据属性值来确定位置，称为倒排索引，索引由次关键字和记录号表构成，记录号表存储具有相同次关键字的记录号。
上面介绍的都是静态查找表，查找方便，但对表内元素进行插入和删除时，就会非常麻烦，下面介绍既方便查找，又方便插入和删除的动态查找表
二叉排序树
定义：又称为二叉查找树，它或者为空树，或者具有以下性质
- 若左子树不空，则左子树所有结点小于根节点
- 若右子树不空，则右子树所有结点大于根节点
- 左右子树都是二叉排序树
PS：二叉排序树中不能有重复的结点
查找代码：
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
/* 二叉树的二叉链表结点结构定义 */
typedef struct BiTNode /* 结点结构 */
{
int data; /* 结点数据 */
struct BiTNode *lchild, *rchild; /* 左右孩子指针 */
} BiTNode, *BiTree;
/* 递归查找二叉排序树T中是否存在key, */
/* 指针f指向T的双亲，其初始调用值为NULL */
/* 若查找成功，则指针p指向该数据元素结点，并返回TRUE */
/* 否则指针p指向查找路径上访问的最后一个结点并返回FALSE */
Status SearchBST(BiTree T, int key, BiTree f, BiTree *p)
{
if (!T) /* 查找不成功 */
{
*p = f;
return FALSE;
}
else if (key==T->data) /* 查找成功 */
{
*p = T;
return TRUE;
}
else if (key<T->data)
return SearchBST(T->lchild, key, T, p); /* 在左子树中继续查找 */
else
return SearchBST(T->rchild, key, T, p); /* 在右子树中继续查找 */
}
插入代码：
/* 当二叉排序树T中不存在关键字等于key的数据元素时， */
/* 插入key并返回TRUE，否则返回FALSE */
Status InsertBST(BiTree *T, int key)
{
BiTree p,s;
if (!SearchBST(*T, key, NULL, &p)) /* 查找不成功 */
{
s = (BiTree)malloc(sizeof(BiTNode));
s->data = key;
s->lchild = s->rchild = NULL;
if (!p)
*T = s; /* 插入s为新的根结点 */
else if (key<p->data)
p->lchild = s; /* 插入s为左孩子 */
else
p->rchild = s; /* 插入s为右孩子 */
return TRUE;
}
else
return FALSE; /* 树中已有关键字相同的结点，不再插入 */
}
二叉排序树删除思路，相对于插入，删除需要考虑更多的东西
- 删除叶子结点，直接删除
- 非叶子结点，只有左子树或右子树，则删去该结点，让该结点的左子树或右子树取代该结点的位置
- 既有左子树，也有右子树，则去该结点的直接前驱（或者直接后继），将直接前驱赋值给该结点，再删去它的直接前驱。
代码如下：
/* 从二叉排序树中删除结点p，并重接它的左或右子树。 */
Status Delete(BiTree *p)
{
BiTree q,s;
if((*p)->rchild==NULL) /* 右子树空则只需重接它的左子树（待删结点是叶子也走此分支) */
{
q=*p; *p=(*p)->lchild; free(q);
}
else if((*p)->lchild==NULL) /* 只需重接它的右子树 */
{
q=*p; *p=(*p)->rchild; free(q);
}
else /* 左右子树均不空 */
{
q=*p; s=(*p)->lchild;
while(s->rchild) /* 转左，然后向右到尽头（找待删结点的前驱） */
{
q=s;
s=s->rchild;
}
(*p)->data=s->data; /* s指向被删结点的直接前驱（将被删结点前驱的值取代被删结点的值） */
if(q!=*p)
q->rchild=s->lchild; /* 重接q的右子树 */
else
q->lchild=s->lchild; /* 重接q的左子树 */
free(s);
}
return TRUE;
}
/* 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点, */
/* 并返回TRUE；否则返回FALSE。 */
Status DeleteBST(BiTree *T,int key)
{
if(!*T) /* 不存在关键字等于key的数据元素 */
return FALSE;
else
{
if (key==(*T)->data) /* 找到关键字等于key的数据元素 */
return Delete(T);
else if (key<(*T)->data)
return DeleteBST(&(*T)->lchild,key);
else
return DeleteBST(&(*T)->rchild,key);
}
}
小结：二叉排序树以链表的形式存储，保持了链表结构插入删除操作时不用移动数据元素的优点，当二叉排序树结构较为均衡，即它的深度与相同结点树的完全二叉树相同时，时间复杂度为O(log n),当二叉排序树的深度与相同结点的斜树相同时，它的时间复杂度为O(n).
平衡二叉树（AVL树）
定义：平衡二叉树是在排序二叉树的一种改进，它也是排序二叉树，且每个结点的左右子树高度差至多为1.
BF:左子树高度减去右子树高度之值。
最小不平衡子树：距离插入结点最近的，且平衡因子的绝对值大于1的结点为根的子树。
构建思路：在构建二叉排序树的过程中，每当插入一个结点，就检查是否因插入破坏了树的平衡性，若否，继续插入，若是，则找出最小不平衡子树，调整最小不平衡子树内部各结点的连接关系，进行相应的旋转 ，使之成为新的平衡子树。当最小不平衡子树的根结点的平衡因子大于1时，即左边结点多，右旋（顺时针），当小于-1时，右边孩子多，左旋（逆时针）。但要注意，当跟结点的孩子结点的BF与根节点符号不同时，需要对孩子结点进行一次旋转，使孩子结点的符号与根节点的符号相同。
算法如下：
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
/* 二叉树的二叉链表结点结构定义 */
typedef struct BiTNode /* 结点结构 */
{
int data; /* 结点数据 */
int bf; /* 结点的平衡因子 */
struct BiTNode *lchild, *rchild; /* 左右孩子指针 */
} BiTNode, *BiTree;
/* 对以p为根的二叉排序树作右旋处理， */
/* 处理之后p指向新的树根结点，即旋转处理之前的左子树的根结点 */
void R_Rotate(BiTree *P)
{
BiTree L;
L=(*P)->lchild; /* L指向P的左子树根结点 */
(*P)->lchild=L->rchild; /* L的右子树挂接为P的左子树 */
L->rchild=(*P);
*P=L; /* P指向新的根结点 */
}
/* 对以P为根的二叉排序树作左旋处理， */
/* 处理之后P指向新的树根结点，即旋转处理之前的右子树的根结点0 */
void L_Rotate(BiTree *P)
{
BiTree R;
R=(*P)->rchild; /* R指向P的右子树根结点 */
(*P)->rchild=R->lchild; /* R的左子树挂接为P的右子树 */
R->lchild=(*P);
*P=R; /* P指向新的根结点 */
}
#define LH +1 /* 左高 */
#define EH 0 /* 等高 */
#define RH -1 /* 右高 */
/* 对以指针T所指结点为根的二叉树作左平衡旋转处理 */
/* 本算法结束时，指针T指向新的根结点 */
void LeftBalance(BiTree *T)
{
BiTree L,Lr;
L=(*T)->lchild; /* L指向T的左子树根结点 */
switch(L->bf)
{ /* 检查T的左子树的平衡度，并作相应平衡处理 */
case LH: /* 新结点插入在T的左孩子的左子树上，要作单右旋处理 */
(*T)->bf=L->bf=EH;
R_Rotate(T);
break;
case RH: /* 新结点插入在T的左孩子的右子树上，要作双旋处理 */
Lr=L->rchild; /* Lr指向T的左孩子的右子树根 */
switch(Lr->bf)
{ /* 修改T及其左孩子的平衡因子 */
case LH: (*T)->bf=RH;
L->bf=EH;
break;
case EH: (*T)->bf=L->bf=EH;
break;
case RH: (*T)->bf=EH;
L->bf=LH;
break;
}
Lr->bf=EH;
L_Rotate(&(*T)->lchild); /* 对T的左子树作左旋平衡处理 */
R_Rotate(T); /* 对T作右旋平衡处理 */
}
}
/* 对以指针T所指结点为根的二叉树作右平衡旋转处理， */
/* 本算法结束时，指针T指向新的根结点 */
void RightBalance(BiTree *T)
{
BiTree R,Rl;
R=(*T)->rchild; /* R指向T的右子树根结点 */
switch(R->bf)
{ /* 检查T的右子树的平衡度，并作相应平衡处理 */
case RH: /* 新结点插入在T的右孩子的右子树上，要作单左旋处理 */
(*T)->bf=R->bf=EH;
L_Rotate(T);
break;
case LH: /* 新结点插入在T的右孩子的左子树上，要作双旋处理 */
Rl=R->lchild; /* Rl指向T的右孩子的左子树根 */
switch(Rl->bf)
{ /* 修改T及其右孩子的平衡因子 */
case RH: (*T)->bf=LH;
R->bf=EH;
break;
case EH: (*T)->bf=R->bf=EH;
break;
case LH: (*T)->bf=EH;
R->bf=RH;
break;
}
Rl->bf=EH;
R_Rotate(&(*T)->rchild); /* 对T的右子树作右旋平衡处理 */
L_Rotate(T); /* 对T作左旋平衡处理 */
}
}
/* 若在平衡的二叉排序树T中不存在和e有相同关键字的结点，则插入一个 */
/* 数据元素为e的新结点，并返回1，否则返回0。若因插入而使二叉排序树 */
/* 失去平衡，则作平衡旋转处理，布尔变量taller反映T长高与否。 */
Status InsertAVL(BiTree *T,int e,Status *taller)
{
if(!*T)
{ /* 插入新结点，树“长高”，置taller为TRUE */
*T=(BiTree)malloc(sizeof(BiTNode));
(*T)->data=e; (*T)->lchild=(*T)->rchild=NULL; (*T)->bf=EH;
*taller=TRUE;
}
else
{
if (e==(*T)->data)
{ /* 树中已存在和e有相同关键字的结点则不再插入 */
*taller=FALSE; return FALSE;
}
if (e<(*T)->data)
{ /* 应继续在T的左子树中进行搜索 */
if(!InsertAVL(&(*T)->lchild,e,taller)) /* 未插入 */
return FALSE;
if(*taller) /* 已插入到T的左子树中且左子树“长高” */
switch((*T)->bf) /* 检查T的平衡度 */
{
case LH: /* 原本左子树比右子树高，需要作左平衡处理 */
LeftBalance(T); *taller=FALSE; break;
case EH: /* 原本左、右子树等高，现因左子树增高而使树增高 */
(*T)->bf=LH; *taller=TRUE; break;
case RH: /* 原本右子树比左子树高，现左、右子树等高 */
(*T)->bf=EH; *taller=FALSE; break;
}
}
else
{ /* 应继续在T的右子树中进行搜索 */
if(!InsertAVL(&(*T)->rchild,e,taller)) /* 未插入 */
return FALSE;
if(*taller) /* 已插入到T的右子树且右子树“长高” */
switch((*T)->bf) /* 检查T的平衡度 */
{
case LH: /* 原本左子树比右子树高，现左、右子树等高 */
(*T)->bf=EH; *taller=FALSE; break;
case EH: /* 原本左、右子树等高，现因右子树增高而使树增高 */
(*T)->bf=RH; *taller=TRUE; break;
case RH: /* 原本右子树比左子树高，需要作右平衡处理 */
RightBalance(T); *taller=FALSE; break;
}
}
}
return TRUE;
}
int main(void)
{
int i;
int a[10]={3,2,1,4,5,6,7,10,9,8};
BiTree T=NULL;
Status taller;
for(i=0;i<10;i++)
{
InsertAVL(&T,a[i],&taller);
}
printf("本样例建议断点跟踪查看平衡二叉树结构");
return 0;
}
PS：建议看的时候一定要想清楚思路，代码是思路的具体化。
多路查找树
定义:每个结点的孩子树可以多于两个，每个结点可以存储多个数据元素。
下面介绍它的四种特殊形式
2-3树
定义：每个结点具有两个孩子（2结点）或三个孩子（3结点），要么没有孩子，要么孩子全有。其中2结点存储一个数据元素，3结点存储一大一小两个元素，左孩子比数据元素小，右孩子比数据元素大，中间孩子介于两数据元素之间，所以2-3树也是没有相同的结点的。
插入
思路：对于2-3树的插入，跟二叉排序树一样，插入操作一定是发生在叶子结点的，可分三种情况：
- 空树，则插入一个2结点即可
- 插入到一个2结点的叶子上，则按顺序将2结点变成3结点即可
- 插入到一个3结点的叶子上，则需要将其拆分，将树中两元素和插入元素的三者中选其一向上移动，这里可以分两种情况
- 连接该3结点的是2结点，则在三者中选取中间值，加入到2结点中，形成新的3结点，而原来的3结点变成两个2结点的叶子结点，分别变成新的3结点的中间孩子和右孩子
- 连接该3结点的还是3结点，叫做B吧，则将三者中的中间值放入上层，此时B中两个元素和中间值形成新的三元，三元中最小值形成2结点，连接原来叶子结点剩下的两个值，三元中最大值形成2结点，连接B中元中原先连接的另外两个孩子。三元中的中间值继续向上，以此类推。
删除操作也同样如此可分为三种情况：
- 在叶子结点，且为3结点，则直接删除即可
- 在叶子结点，为2结点…
- 在非叶子结点
内容较多，就简单讲讲，不具体列出
2-3-4树
定义：在2-3树的概念上，加上了一个4结点。
B树
定义：B树一种平衡的多路查找树，结点最大的孩子数目为B树的阶。
B+树
散列表查找
定义：散列表，也叫哈希表。通过散列技术在数据元素存储位置和相应的关键字之间建立一个确定的对应关系f，使得每一个关键字对应一个存储位置。查找时，根据这个对应关系查找关键字的映射地址，若地址中存在记录，则查找成功，若不存在，查找失败，这种查找方式，称为散列表查找。其中这种对应关系称为散列函数，又称哈希函数，定义一组连续的存储空间存储数据元素，这个连续的存储空间称为散列表或哈希表，存储地址称为散列地址。
散列过程
- 按照对应关系f将数据元素存储在关键字相应的散列地址中
- 根据关键字找到对应关系的散列地址，按地址进行访问
冲突：两个不同的关键字，通过对应关系f得到的映射地址相同，这种现象称为重突，这两个关键字称为同义词。
散列函数的构造方法
设计原则
- 计算简单，计算复杂会降低查找的效率
- 散列地址分布均匀，既可以有效利用空间，并减少解决冲突所耗费的时间
散列方法
直接定址法：取关键字的某个线性函数值为散列地址，即f(key)=a*key+b(a、b为常数)
适合查找表较小，且知道关键字分布、关键字连续的情况。
数字分析法：根据关键字的特性，或抽取或位移或运算等等，总之根据关键字的特性，提供一个散列函数，能够合理的将关键字映射到散列表的各个位置上。
平方取中法：顾名思义，将关键字平方，取中间的位数做散列地址。
适合不知道关键字分布，且位数不是很多的情况
折叠法：将关键字从左到右分割成位数相等的几部分，将这几部分叠加求和，并按哈希表的表长，取后几位作为散列地址。
适合不知道关键字的分布，且关键字位数较多的情况。
除留取余法：即f(key)=key mod p (p<=m)，m为哈希表长。
根据经验：通常p为小于或等于表长的最小质数或不包含小于20质因子的合数
处理冲突的方法
开放定址法：一旦发生冲突，就去寻找下一个空的散列地址，只要散列表足够大，总能找到空的散列地址，将记录存入。
再散列函数法：准备多个散列函数，当发生冲突时，换另一个散列函数。
链地址法：将所有关键字为同义词的记录存储在一个单链表中，称为同义词子表。
公共溢出法：为所有有冲突的关键字建立了一个公共溢出区存放，当哈希表内元素与关键值并不相同时，就去公共溢出区查找。
相关代码：
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef struct
{
int *elem; /* 数据元素存储基址，动态分配数组 */
int count; /* 当前数据元素个数 */
}HashTable;
int m=0; /* 散列表表长，全局变量 */
/* 初始化散列表 */
Status InitHashTable(HashTable *H)
{
int i;
m=HASHSIZE;
H->count=m;
H->elem=(int *)malloc(m*sizeof(int));
for(i=0;i<m;i++)
H->elem[i]=NULLKEY;
return OK;
}
/* 散列函数 */
int Hash(int key)
{
return key % m; /* 除留余数法 */
}
/* 插入关键字进散列表 */
void InsertHash(HashTable *H,int key)
{
int addr = Hash(key); /* 求散列地址 */
while (H->elem[addr] != NULLKEY) /* 如果不为空，则冲突 */
{
addr = (addr+1) % m; /* 开放定址法的线性探测 */
}
H->elem[addr] = key; /* 直到有空位后插入关键字 */
}
/* 散列表查找关键字 */
Status SearchHash(HashTable H,int key,int *addr)
{
*addr = Hash(key); /* 求散列地址 */
while(H.elem[*addr] != key) /* 如果不为空，则冲突 */
{
*addr = (*addr+1) % m; /* 开放定址法的线性探测 */
if (H.elem[*addr] == NULLKEY || *addr == Hash(key)) /* 如果循环回到原点 */
return UNSUCCESS; /* 则说明关键字不存在 */
}
return SUCCESS;
}
int main()
{
int arr[HASHSIZE]={12,67,56,16,25,37,22,29,15,47,48,34};
int i,p,key,result;
HashTable H;
key=39;
InitHashTable(&H);
for(i=0;i<m;i++)
InsertHash(&H,arr[i]);
result=SearchHash(H,key,&p);
if (result)
printf("查找 %d 的地址为：%d \n",key,p);
else
printf("查找 %d 失败。\n",key);
for(i=0;i<m;i++)
{
key=arr[i];
SearchHash(H,key,&p);
printf("查找 %d 的地址为：%d \n",key,p);
}
return 0;
}
小结
散列表中冲突是不可避免的，选择一个合适的解决冲突的方法对查找的效率有较大的帮助，其次散列表的平均查找长度取决于装填因子α（α=表中记录个数/散列表长度），因此适当将散列表放大，虽然浪费了一定的空间，但可以大大的提高查找效率，还是值得的。