查找基本概念：
列表：由同一类型的数据元素组成的集合。
关键码：数据元素中的某个数据项，可以标识列表中的一个或一组数据元素。
键值：关键码的值。
主关键码：可以唯一地标识一个记录的关键码。
次关键码：不能唯一地标识一个记录的关键码。
查找 ：在具有相同类型的记录构成的集合中找出满足给定条件的记录。
查找的结果 ：若在查找集合中找到了与给定值相匹配的记录，则称查找成功；否则，称查找失败。
静态查找 ：不涉及插入和删除操作的查找 。
动态查找 ：涉及插入和删除操作的查找。
查找结构 ：面向查找操作的数据结构 ，即查找基于的数据结构。
线性表：适用于静态查找，主要采用顺序查找技术、折半查找技术。
树表：适用于动态查找，主要采用二叉排序树的查找技术。
散列表：静态查找和动态查找均适用，主要采用散列技术。
顺序查找：
基本思想： 从线性表的一端向另一端逐个将关键码与给定值进行比较， 若相等，则查找成功，给出该记录在表中的位置； 若整个表检测完仍未找到与给定值相等的关键码，则查找失败，给出失败信息。
改进顺序查找：
基本思想：设置“哨兵”。 哨兵就是待查值， 将哨兵放在查找方向的尽头处， 免去了在查找过程中每一次比较后都要判断查找位置是否越界，从而提高查找速度。
int LineSearch :: SeqSearch(int k)
{
int i = length; //从数组高端开始比较
data[0] = k; //设置哨兵
while (data[i] != k) //不用判断下标i是否越界
i--;
return i;
}
顺序查找的优点：
算法简单而且使用面广。
对表中记录的存储结构没有任何要求，顺序存储和链接存储均可；
对表中记录的有序性也没有要求，无论记录是否按关键码有序均可。
顺序查找的缺点：
平均查找长度较大，特别是当待查找集合中元素较多时，查找效率较低。
折半查找：
适用条件： 线性表中的记录必须按关键码有序； 必须采用顺序存储。
基本思想： 在有序表中（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
}
折半查找判定树：折半查找的过程可以用二叉树来描述， 树中的每个结点对应有序表中的一个记录， 结点的值为该记录在表中的位置。 通常称这个描述折半查找过程的二叉树为折半查找判定树，简称判定树。
折半查找判定树构造方法：⑴ 当n=0时，折半查找判定树为空；
⑵ 当n＞0时， 折半查找判定树的根结点为mid=(n+1)/2，
根结点的左子树是与有序表r[1] ~ r[mid-1]相对应的折半查找判定树，
根结点的右子树是与r[mid+1] ~ r[n]相对应的折半查找判定树。
判定树性质：任意结点的左右子树中结点个数最多相差1
任意结点的左右子树的高度最多相差1
任意两个叶子所处的层次最多相差1
二叉排序树：
二叉排序树（也称二叉查找树）：或者是一棵空的二叉树，
或者是具有下列性质的二叉树： ⑴若它的左子树不空，则左子树上所有结点的值均小于根结点的值；
⑵若它的右子树不空，则右子树上所有结点的值均大于根结点的值；
⑶ 它的左右子树也都是二叉排序树。
二叉树插入算法：
若二叉排序树为空树，则新插入的结点为新的根结点； 否则，如果插入的值比根节点值大，则在右子树中进行插入；否则，在左子树中进行插入。 递归。
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);
}
构造二叉排序树：
BiSortTree::BiSortTree(int a[ ], int n)
{
root = NULL;
for (int i = 0; i < n; i++)
root = InsertBST(root, a[i]);
}
二叉排序树的删除：
分三种情况讨论： 被删除的结点是叶子； 操作：将双亲结点中相应指针域的值改为空。
被删除的结点只有左子树或者只有右子树；操作：将双亲结点的相应指针域的值指向被删除结点的左子树（或右子树）。
被删除的结点既有左子树，也有右子树。操作：以其前驱（左子树中的最大值）替代之，然后再删除该前驱结点。
操作：以其后继（右子树中的最小值）替代之，然后再删除该前驱结点。
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;
} //左右子树均不空的情况处理完毕
}
二叉排序树的查找：
在二叉排序树中查找给定值k的过程是：
⑴ 若root是空树，则查找失败；
⑵ 若k＝root->data，则查找成功；否则
⑶ 若k＜root->data，则在root的左子树上查找；否则
⑷ 在root的右子树上查找。 上述过程一直持续到k被找到或者待查找的子树为空，如果待查找的子树为空，则查找失败。 二叉排序树的查找效率在于只需查找二个子树之一。
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型
B=A->lchild；
A->lchild=B->rchild；
B->rchild=A；
A->bf=0； B->bf=0；
if (FA==NULL) root=B;
else if (A==FA->lchild) FA->lchild=B;
else FA->rchild=B；
2. RR型
B=A->rchild；
A->rchild=B->lchild；
B->lchild=A；
A->bf=0； B->bf=0；
if (FA==NULL)
root=B;
else if (A==FA->lchild)
FA->lchild=B;
else
FA->rchild=B；
3. LR型
B=A->lchild；C=B->rchild；
B->rchild=C->lchild；
A->lchild=C->rchild；
C->lchild=B； C->rchild=A；
if (S->key <C->key) /* 在C-L下插入S */
{ A->bf=-1； B->bf=0 ； C->bf=0； }
if (S->key >C->key) /* 在C-R下插入S */
{ A->bf=0； B->bf=1 ； C->bf=0； }
if (S->key ==C->key) /* C本身就是插入的新结点S */
{ A->bf=0； B->bf=0 ；C->bf=0 }
if (FA==NULL) root=C;
else if (A==FA->lchild) FA->lchild=C;
else FA->rchild=C；
4. RL型
B=A->rchild； C=B->lchild；
B->lchild=C->rchild；
A->rchild=C->lchild；
C->lchild=A； C->rchild=B；
然后针对上述三种不同情况，修改A、B、C的平衡因子：
if (S->key <C->key) /* 在CL下插入S */
{ A->bf=0； B->bf=-1 ； C->bf=0； }
if (S->key >C->key) /* 在CR下插入S */
{ A->bf=1； B->bf=0 ； C->bf=0； }
if (S->key ==C->key) /* C本身就是插入的新结点S */
{ A->bf=0； B->bf=0 ；C->bf=0 }
最后，将调整后的二叉树的根结点C“接到”原A处。 令A原来的父指针为FA，如果FA非空，则用C代替A做FA的左子或右子；否则，原来A就是根结点，此时应令根指针t指向C：
if (FA==NULL) root=C;
else if (A==FA->lchild) FA->lchild=C;
else FA->rchild=C；
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-1)，
此时需要分裂节点，
将节点中第[m/2]+1个数据插入到当前节点的前驱中，
当前节点分裂为两个节点。
删除：当最下层结点中的关键字数大于m/2 -1 时，可直接删除。
当最下层待删关键字所在结点中关键字数目为最低要求m/2 -1时，如果其左（右）兄弟中关键字数目大于m/2 -1，则可采用“父子换位法”。
当最下层待删结点及其左右兄弟中的关键字数目均为最低要求数目m/2 -1时，需要进行合并处理，合并过程与插入时的分裂过程“互逆”，合并一次， 分支数少一，可能出现 “连锁合并”， 当合并到根时， 各分支深度同时减1。
B+树
B+树是B-树的变体，也是一种多路搜索树：
m阶B+树的结构定义如下：
(1)每个结点至多有m个子结点；
(2)每个结点(除根外)至少有ceiling(m/2)个子结点；
(3)根结点至少有两个子结点；
(4)有k个子结点的结点必有k个关键码。
m阶B＋树：是满足下列特性的树：
⑴ 含有m个关键码，每一个关键码对应一棵子树。
⑵ 关键码Ki是它所对应的子树的根结点中的最大（或最小）关键码。
⑶ 所有终端结点中包含了全部关键码信息，以及指向关键码记录的指针。
⑷ 所有终端结点按关键码的大小链在一起，形成单链表，并设置头指针。
散列表的查找技术：
散列的基本思想：在记录的存储地址和它的关键码之间建立一个确定的对应关系。这样，不经过比较，一次读取就能得到所查元素的查找方法。
散列表：采用散列技术将记录存储在一块连续的存储空间中，这块连续的存储空间称为散列表。
散列函数：将关键码映射为散列表中适当存储位置的函数。
散列地址：由散列函数所得的存储位置址 。
冲突：对于两个不同关键码ki≠kj，有H(ki)＝H(kj)，即两个不同的记录需要存放在同一个存储位置,ki和kj相对于H称做同义词。
设计散列函数一般应遵循以下原则：
⑴ 计算简单。散列函数不应该有很大的计算量，否则会降低查找效率。
⑵ 函数值即散列地址分布均匀。函数值要尽量均匀散布在地址空间，这样才能保证存储空间的有效利用并减少冲突。
散列函数是关键码的线性函数，即：H(key) = a key + b （a，b为常数）
散列函数——除留余数法：H(key)=key mod p
散列函数——平方取中法：对关键码平方后，按散列表大小，取中间的若干位作为散列地址（平方后截取）。
散列函数——折叠法：将关键码从左到右分割成位数相等的几部分，将这几部分叠加求和，取后几位作为散列地址
处理冲突的方法——开放定址法：由关键码得到的散列地址一旦产生了冲突，就去寻找下一个空的散列地址，并将记录存入。
在线性探测法构造的散列表中查找算法
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; //查找不成功时插入
}
处理冲突的方法——拉链法（链地址法）
基本思想：将所有散列地址相同的记录，即所有同义词的记录存储在一个单链表中（称为同义词子表），在散列表中存储的是所有同义词子表的头指针。
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;
}
}
处理冲突的方法——公共溢出区
基本思想： 散列表包含基本表和溢出表两部分（通常溢出表和基本表的大小相同）， 将发生冲突的记录存储在溢出表中。 查找时，对给定值通过散列函数计算散列地址，先与基本表的相应单元进行比较，若相等，则查找成功；否则，再到溢出表中进行顺序查找。
来源：CSDN
作者：qq_43632319
链接：https://blog.csdn.net/qq_43632319/article/details/103701275