一些定义
查找（Searching)
就是根据给定的某个值，在査找表中确定一个其关键字等于给定值的数据元素
查找表（Search Table）
是由同一类型的数据元素（记录）构成的集合
关键字（Key）
是数据元素中某个数据项的值。又称为键值。用它可以表示一个数据元素，也可以标识一个记录的某个数据项（字段），我们称为关键码
若关键字可以唯一地标识一个记录，则称此关键字为主关键字（Primary Key)
对于那些可以识别多个属于元素（记录）的关键字，我们称为次关键字（Secondary Key)
静态查找表（Static Search Table）
只作查找操作的查找表
1. 査询某个“特定的“数据元素是否在查找表中
2. 检索某个“特定的“数据元素和各种属性
动态查找表（Dynamic Search Table）
在査找过程中同时插入查找表中不存在的数据元素，或者从查找表中删除已经存在的某个数据元素；显然动态查找表的操作就是 2 个动作
1. 查找时插入数据元素
2. 查找时删除数据元素；
顺序查找（Sequential Search）
又称为线性查找, 是最基本的查找技术它的查找过程：从表中的第一个（或最后一个记录开始，逐个进行记录关键字和给定值比较
1. 若某个记录的关键字和给定值相等，则查找成功，找到所查记录；
2. 如果直到最后一个（或第一个）记录，其关键字和给定值比较都不等时，则表中没有所查的记录，查找不成功
//1.顺序查找
//a为数组,n为查找的数组个数,key为要查找的关键字;
int Sequential_Search(int *a,int n,int key){
for (int i = 1; i <= n ; i++)
if (a[i] == key)
return i;
return 0;
}
//2.顺序查找_哨兵
int Sequential_Search2(int *a,int n,int key){
int i;
//设置a[0]为关键字值,称为'哨兵'
a[0] = key;
//循环从数组尾部开始
i = n;
while (a[i] != key) {
i--;
}
//返回0,则说明查找失败
return i;
}
折半查找（Binary Search）
又称为二分查找，它的前提是线性表中的记录必须是关键码有序（通常是从小到大有序）线性表必须采用顺序存储
思想：
在有序表中，取中间记录作为比较对象，若给定值与中间记录的关键字相等则查找成功；
若给定值小于中间的记录关键字，则在中间记录的左半区继续査找
若给定的值大于中间记录的关键字，则在中间记录的右半区继续查找，不断重复以上的过程，直到査找成功，或所以查找区域无记录，查找失败为止。
//折半查找算法
//假设数组a,已经是有序的(从小到大)
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]) {
//若key比a[mid] 小,则将最高下标调整到中位下标小一位;
high = mid-1;
}else if(key > a[mid]){
//若key比a[mid] 大,则将最低下标调整到中位下标大一位;
low = mid+1;
}else
//若相等则说明mid即为查找到的位置;
return mid;
}
return 0;
}
插值查找
插值查找是优化的折半查找，修改mid值的计算方式，在一定程度上优化计算次数
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]) {
//若key比a[mid]插值小,则将最高下标调整到插值下标小一位;
high = mid-1;
}else if(key > a[mid]){
//若key比a[mid]插值 大,则将最低下标调整到插值下标大一位;
low = mid+1;
}else
//若相等则说明mid即为查找到的位置;
return mid;
}
return 0;
}
斐波拉契查找
条件：
(1)数据必须采用顺序存储结构；(2)数据必须有序。
原理：
(1)最接近查找长度的斐波那契值来确定拆分点;(2)黄金分割。
斐波那契查找与折半查找很相似，他是根据斐波那契序列的特点对有序表进行分割的。他要求开始表中记录的个数为某个斐波那契数小1，即n=F(k)-1;
开始将key值与黄金分割点的值，即第 F(k-1）位置的记录进行比较(mid=low+F(k-1)-1),比较结果也分为三种
1）相等，mid位置的元素即为所求
2）> ,low=mid+1,k-=2;说明:low=mid+1说明待查找的元素在[mid+1,hign]范围内，k-=2 说明范围[mid+1,high]内的元素个数为n-（F(k-1))= Fk-1-F(k-1)=Fk-F(k-1)-1=F(k-2)-1个，所以可以递归的应用斐波那契查找
3)< ,high=mid-1,k-=1;说明:high=mid-1说明待查找的元素在[low,mid-1]范围内，k-=1 说明范围[low,mid-1]内的元素个数为F(k-1)-1个，所以可以递归的应用斐波那契查找
//斐波拉契查找
int F[100]; /* 斐波那契数列 */
int Fibonacci_Search(int *a,int n,int key){
int low,high,mid,i,k;
//最低下标为记录的首位;
low = 1;
//最高下标为记录的末位;
high = n;
k = 0;
//1.计算n在斐波拉契数列的位置; k=7
while (n > F[k]-1) {
k++;
}
//2.将数组a不满的位置补全值; 按F[k] 数补齐
for(i = n;i < F[k]-1;i++)
a[i] = a[n];
//3.
while (low <= high) {
//计算当前分隔的下标;
//mid无限接近黄金分割 mid左边有 F[k-1]-1 个数据 右边有 F[k-2]-1 个数据
mid = low + F[k-1]-1;
if (key < a[mid]) {
//若查找的记录小于当前分隔记录;
//将最高下标调整到分隔下标mid-1处;
high = mid-1;
//斐波拉契数列下标减1位;
k = k-1;
}else if(key > a[mid]){
//若查找的记录大于当前的分隔记录;
//最低下标调整到分隔下标mid+1处
low = mid+1;
//斐波拉契数列下标减2位;
k = k-2;
}else{
if (mid <= n) {
//若相等则说明,mid即为查找的位置;
return mid;
}else
{
//若mid>n,说明是补全数值,返回n;
return n;
}
}
}
return 0;
}
mid计算方法对比：
int main(int argc, const char * argv[]) {
// insert code here...
printf("Hello, 静态查找!\n\n");
int a[MAXSIZE+1],i,result;
int arr[MAXSIZE] = {0,1,16,24,35,47,59,62,73,88,99};
for (i = 0; i<= MAXSIZE; i++) {
a[i] = i;
}
//1,顺序查找
result=Sequential_Search(a,MAXSIZE,MAXSIZE);
printf("顺序查找:%d\n",result);
//2,顺序查找_哨兵
result=Sequential_Search2(arr,MAXSIZE,999);
printf("顺序查找_哨兵:%d \n",result);
//3.折半查找 4次
result=Binary_Search(arr,10,62);
printf("折半查找:%d \n",result);
result=bs(arr,10,62);
printf("折半查找bs:%d \n",result);
//4.插值查找 2次
result=Interpolation_Search(arr,10,62);
printf("插值查找:%d \n",result);
//5.斐波拉契查找
//斐波拉契数列计算;
F[0]=0;
F[1]=1;
for(i = 2;i < 100;i++)
{
F[i] = F[i-1] + F[i-2];
}
// result=Fibonacci_Search(arr,10,99);
// printf("斐波拉契查找:%d \n",result);
result=Fibonacci_Search(arr,10,62);
printf("斐波拉契查找:%d \n",result);
printf("\n");
return 0;
}
/*
f[k]-1 = f[k-1]-1 + f[k-2]-1 + mid
k=7
f[7]-1 = f[6]-1 + f[5]-1 +1
12 = 7+4+1
*/
/*
[0] = 0
[1] = 1
[2] = 1
[3] = 2
[4] = 3
[5] = 5
[6] = 8
[7] = 13
[8] = 21
[9] = 34
[10] = 55
[11] = 89
[12] = 144
[13] = 233
[14] = 377
[15] = 610
[16] = 987
[17] = 1597
[18] = 2584
[19] = 4181
[20] = 6765
*/
二叉排序树（Binary Sort Tree）
又称为二叉查找树或者二叉搜索树，它或者是一颗空树。或者是一颗具有下列性质的二叉树
- 1.若它的左子树不空，则左子树上所有结点的值均小于它的根结构的值
- 2.若它的右子树不空，则右子树上的所有结点的值均大于它的根结点的值
- 3.它的左右子树也分别是二叉排序树
结点结构
//结点结构
typedef struct BiTNode
{
//结点数据
int data;
//左右孩子指针
struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;
查找
/*
递归查找二叉排序树T中,是否存在key;
f: 指针f指向T的双亲,其初始值为NULL;
p: 若查找成功,则指针p指向该数据元素的结点,并且返回TRUE;
若指针p指向查找路径上访问的最后一个结点则返回FALSE;
*/
Status SearchBST(BiTree T,int key,BiTree f, BiTree *p){
// 如果 T （有可能是左孩子 右孩子 双亲节点） 指针为空，说明查找失败，令 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;
//1.查找插入的值是否存在二叉树中;查找失败则->
if (!SearchBST(*T, key, NULL, &p)) {
//2.初始化结点s,并将key赋值给s,将s的左右孩子结点暂时设置为NULL
s = (BiTree)malloc(sizeof(BiTNode));
s->data = key;
s->lchild = s->rchild = NULL;
//3.
if (!p) {
//如果p为空,说明是空树 则将s作为二叉树新的根结点;
*T = s;
}else if(key < p->data){
//如果key<p->data,则将s插入为左孩子;
p->lchild = s;
}else
//如果key>p->data,则将s插入为右孩子;
p->rchild = s;
return TRUE;
}
return FALSE;
}
删除
删除分为3种情况：
- 删除的是叶子节点
- 删除的节点只有左孩子或只有右孩子
- 左孩子右孩子都有（根据中序排序，用该节点的直接前驱或直接后继替换待删除节点）
//3.从二叉排序树中删除结点p,并重接它的左或者右子树;
Status Delete(BiTree *p){
BiTree temp,s;
if((*p)->rchild == NULL){
//情况1: 如果当前删除的结点,右子树为空.那么则只需要重新连接它的左子树;
//①将结点p临时存储到temp中;
temp = *p;
//②将p指向到p的左子树上;
*p = (*p)->lchild;
//③释放需要删除的temp结点;
free(temp);
}else if((*p)->lchild == NULL){
//情况2:如果当前删除的结点,左子树为空.那么则只需要重新连接它的右子树;
//①将结点p存储到temp中;
temp = *p;
//②将p指向到p的右子树上;
*p = (*p)->rchild;
//③释放需要删除的temp结点
free(temp);
}else{
//情况③:删除的当前结点的左右子树均不为空;
//①将结点p存储到临时变量temp, 并且让结点s指向p的左子树（找直接前驱，要找直接后继的话，左右互换就行）
temp = *p;
s = (*p)->lchild;
//②将s指针,向右到尽头(目的是找到待删结点的前驱)
//-在待删除的结点的左子树中,从右边找到直接前驱 （中序遍历的直接前驱）
//-使用`temp`保存好直接前驱的双亲结点
//s：待删除节点p的直接前驱结点 即用s替换p(也可以用直接后继替换)
while (s->rchild) {
temp = s;
s = s->rchild;
}
//③将要删除的结点p数据赋值成s->data;
(*p)->data = s->data;
//④重连子树
//-如果temp 不等于p,则将S->lchild 赋值给temp->rchild
//-如果temp 等于p,则将S->lchild 赋值给temp->lchild
if(temp != *p)//判断结点 p 的左子树 s 是否有右子树
temp->rchild = s->lchild;//若有，则在删除直接前驱结点的同时，令前驱的左孩子结点改为 q 指向结点的孩子结点
else
temp->lchild = s->lchild;//否则，直接将左子树上移即可
//⑤删除s指向的结点; free(s)
free(s);
}
return TRUE;
}
//4.查找结点,并将其在二叉排序中删除;
/* 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点, */
/* 并返回TRUE；否则返回FALSE。 */
Status DeleteBST(BiTree *T,int key)
{
//不存在关键字等于key的数据元素
if(!*T)
return FALSE;
else
{
//找到关键字等于key的数据元素
if (key==(*T)->data)
return Delete(T);
else if (key<(*T)->data)
//关键字key小于当前结点,则缩小查找范围到它的左子树;
return DeleteBST(&(*T)->lchild,key);
else
//关键字key大于当前结点,则缩小查找范围到它的右子树;
return DeleteBST(&(*T)->rchild,key);
}
}
void order(BiTree t)//中序输出
{
if(t == NULL){
return ;
}
order(t->lchild);
printf("%d ", t->data);
order(t->rchild);
}
