16*：查找专题静态查找以及二叉搜索树的实现：(顺序查找、折半查找、插值查找、斐波那契查找)、（二叉排序树）

问题

(顺序查找、折半查找、插值查找、斐波那契查找)、（二叉排序树）

预备

正文

一：定义

查找（Searching)

就是根据给定的某个值，在査找表中确定一个其关键字等于给定值的数据元素

查找表（Search Table）

是由同一类型的数据元素（记录）构成的集合

关键字（Key）

是数据元素中某个数据项的值。又称为键值。用它可以表示一个数据元素，也可以标识一个记录的某个数据项（字段），我们称为关键码

若关键字可以唯一地标识一个记录，则称此关键字为主关键字（Primary Key)

对于那些可以识别多个属于元素（记录）的关键字，我们称为次关键字（Secondary Key)

静态查找表（Static Search Table）

只作查找操作的查找表

1. 査询某个“特定的“数据元素是否在查找表中 
2. 检索某个“特定的“数据元素和各种属性

动态查找表（Dynamic Search Table）

在査找过程中同时插入查找表中不存在的数据元素，或者从查找表中删除已经存在的某个数据元素；显然动态查找表的操作就是 2 个动作

1. 查找时插入数据元素
2. 查找时删除数据元素；

二：顺序查找（Sequential Search）

又称为线性查找, 是最基本的查找技术它的查找过程：从表中的第一个（或最后一个记录开始，逐个进行记录关键字和给定值比较

1. 若某个记录的关键字和给定值相等，则查找成功，找到所查记录；
2. 如果直到最后一个（或第一个）记录，其关键字和给定值比较都不等时，则表中没有所查的记录，查找不成功

#include "stdio.h"
#include "stdlib.h"

#include "math.h"
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 100 /* 存储空间初始分配量 */
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */

//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;
}

//3.折半查找算法
//假设数组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;
}

//4. 插值查找
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;
}
//5.斐波拉契查找
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为斐波拉契数列的位置;
    while (n > F[k]-1) {
        k++;
    }
    
    //2.将数组a不满的位置补全值;
    for(i = n;i < F[k]-1;i++)
        a[i] = a[n];
    
    //3.
    while (low <= high) {
        
        //计算当前分隔的下标;
        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;
}
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(a,MAXSIZE,1);
    printf("顺序查找_哨兵:%d \n",result);
    
    //3.折半查找
    result=Binary_Search(arr,10,62);
    printf("折半查找:%d \n",result);
    
    //4.插值查找
    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,59);
    printf("斐波拉契查找:%d \n",result);
    
    printf("\n");
    return 0;
}

1：顺序查找

顺序查找(Sequential Search), ⼜又称为线性查找. 是最基本的查找技术. 它的查找过程: 从表中的第一个(或最后一个)记录开始,逐个进⾏行行记录关键字和给定值⽐比较;

1：若某个记录的关键字和给定值相等,则查找成功,找到所查记录;

2：如果直到最后⼀一个(或第⼀一个)记录, 其关键字和给定值⽐比较都不不等时, 则表中没有所查的记录,查找不不成功;

2：折半查找（Binary Search）

又称为二分查找，它的前提是线性表中的记录必须是关键码有序（通常是从小到大有序）线性表必须采用顺序存储

思想：
在有序表中，取中间记录作为比较对象，若给定值与中间记录的关键字相等则查找成功；
若给定值小于中间的记录关键字，则在中间记录的左半区继续査找
若给定的值大于中间记录的关键字，则在中间记录的右半区继续查找，不断重复以上的过程，直到査找成功，或所以查找区域无记录，查找失败为止。

3：插值查找

4：斐波那契查找

条件：
(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个，所以可以递归的应用斐波那契查找

5：顺序查找-总结

三：二叉排序树

1：定义

又称为二叉查找树或者二叉搜索树，它或者是一颗空树。或者是一颗具有下列性质的二叉树

1.若它的左子树不空，则左子树上所有结点的值均小于它的根结构的值
2.若它的右子树不空，则右子树上的所有结点的值均大于它的根结点的值
3.它的左右子树也分别是二叉排序树

2：构建二叉排序树

假设我们的数据集开始只有一个数{62}，然后现在需要将88插入数据集，于是数据集成了{62,88}，还保持着从小到大有序。再查找有没有58，没有则插入，可此时要想在线性表的顺序存储中有序，就得移动62和88的位置，如图可不可以不移动呢？嗯，当然是可以，那就是二叉树结构。当我们用二叉树的方式时，首先我们将第一个数62定为根结点，88因为比62大，因此让它做62的右子树，58因比62小，所以成为它的左子树。此时58的插入并没有影响到62与88的关系，如下图右图所示。

也就是说，若我们现在需要对集合{62,88,58,47,35,73,51,99,37,93}做查找，在我们打算创建此集合时就考虑用二叉树结构，而且是排好序的二叉树来创建。如下图所示，62、88、58创建好后，下一个数47因比58小，是它的左子树（见③），35是47的左子树（见④），73比62大，但却比88小，是88的左子树（见⑤），51比62小、比58小、比47大，是47的右子树（见⑥），99比62、88都大，是88的右子树（见⑦），37比62、58、47都小，但却比35大，是35的右子树（见⑧），93则因比62、88大是99的左子树（见⑨）。

这样我们就得到了一棵二叉树，并且当我们对它进行中序遍历时，就可以得到一个有序的序列{35,37,47,51,58,62,73,88,93,99}，所以我们通常称它为二叉排序树。

二叉排序树（Binary Sort Tree），又称为二叉查找树。它或者是一棵空树，或者是具有下列性质的二叉树。

若它的左子树不空，则左子树上所有结点的值均小于它的根结构的值；
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
它的左、右子树也分别为二叉排序树。

从二叉排序树的定义也可以知道，它前提是二叉树，然后它采用了递归的定义方法，再者，它的结点间满足一定的次序关系，左子树结点一定比其双亲结点小，右子树结点一定比其双亲结点大。

构造一棵二叉排序树的目的，其实并不是为了排序，而是为了提高查找和插入删除关键字的速度。不管怎么说，在一个有序数据集上的查找，速度总是要快于无序的数据集的，而二叉排序树这种非线性的结构，也有利于插入和删除的实现。

代码实现

#include "stdio.h"
#include "stdlib.h"

#include "math.h"
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 100

typedef int Status;

//二叉树的二叉链表结点结构定义
//结点结构
typedef  struct BiTNode
{
    //结点数据
    int data;
    //左右孩子指针
    struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;

//1.二叉排序树--查找
/*
 递归查找二叉排序树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);  /*  在右子树中继续查找 */
}

//2.二叉排序树-插入
/*  当二叉排序树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.从二叉排序树中删除结点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`保存好直接前驱的双亲结点
        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)
            temp->rchild = s->lchild;
        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);
        
    }
}

int main(int argc, const char * argv[]) {
    // insert code here...
    printf("Hello, 二叉排序树(Binary Sort Tree)!\n");
    int i;
    int a[10]={62,88,58,47,35,73,51,99,37,93};
    BiTree T=NULL;
    
    for(i=0;i<10;i++)
    {
        InsertBST(&T, a[i]);
    }
    
    BiTree p;
    int statusValue = SearchBST(T, 99, NULL, &p);
    printf("查找%d是否成功:%d (1->YES/0->NO)\n",p->data,statusValue);
   
    
    statusValue = DeleteBST(&T,93);
    printf("二叉排序树删除93是否成功:%d (1->YES/0->NO)\n",statusValue);
    statusValue = DeleteBST(&T,47);
    printf("二叉排序树删除47是否成功:%d (1->YES/0->NO)\n",statusValue);
    statusValue = DeleteBST(&T,12);
    printf("二叉排序树删除12是否成功:%d (1->YES/0->NO)\n",statusValue);
    
    
    statusValue = SearchBST(T, 93, NULL, &p);
    printf("查找%d是否成功:%d (1->YES/0->NO)\n",93,statusValue);
    
    statusValue = SearchBST(T, 47, NULL, &p);
    printf("查找%d是否成功:%d (1->YES/0->NO)\n",47,statusValue);
    
    statusValue = SearchBST(T, 99, NULL, &p);
    printf("查找%d是否成功:%d (1->YES/0->NO)\n",99,statusValue);
    
    printf("\n");
    return 0;
}

1：二叉排序树查找操作

1．SearchBST函数是一个可递归运行的函数，函数调用时的语句为SearchBST(T,93,NULL,p)，参数T是一个二叉链表，其中数据如上图所示，key代表要查找的关键字，目前我们打算查找93，二叉树f指向T的双亲，当T指向根结点时，f的初值就为NULL，它在递归时有用，最后的参数p是为了查找成功后可以得到查找到的结点位置。

2．第3～7行，是用来判断当前二叉树是否到叶子结点，显然图8-6-3告诉我们当前T指向根结点62的位置，T不为空，第5～6行不执行。

3．第8～12行是查找到相匹配的关键字时执行语句，显然93≠62，第10～11行不执行。

4．第13～14行是当要查找关键字小于当前结点值时执行语句，由于93>62，第14行不执行。

5．第15～16行是当要查找关键字大于当前结点值时执行语句，由于93>62，所以递归调用SearchBST(T->rchild,key,T,p)。此时T指向了62的右孩子88，如下图所示。

6．此时第二层SearchBST，因93比88大，所以执行第16行，再次递归调用SearchBST(T->rchild,key,T,p)。此时T指向了88的右孩子99，如下图所示。

7．第三层的SearchBST，因93比99小，所以执行第14行，递归调用SearchBST(T->lchild,key,T,p)。此时T指向了99的左孩子93，如下图所示。

8．第四层SearchBST，因key等于T->data，所以执行第10～11行，此时指针p指向93所在的结点，并返回True到第三层、第二层、第一层，最终函数返回True。

2：二叉排序树插入操作

有了二叉排序树的查找函数，那么所谓的二叉排序树的插入，其实也就是将关键字放到树中的合适位置而已，

这段代码非常简单。如果你调用函数是“In-sertBST(&T,93);”，那么结果就是FALSE，如果是“InsertBST(&T,95);”，那么一定就是在93的结点增加一个右孩子95，并且返回True。如下图所示。

有了二叉排序树的插入代码，我们要实现二叉排序树的构建就非常容易了。下面的代码就可以创建一棵二叉树。

int i;
int a[10] = { 62, 88, 58, 47, 35, 73, 51, 99, 37, 93 };
BiTree T = NULL;
for (i = 0; i < 10; i++)
{
    InsertBST(&T, a[i]);
}

3：二叉排序树删除操作

俗话说“请神容易送神难”，我们已经介绍了二叉排序树的查找与插入算法，但是对于二叉排序树的删除，就不是那么容易，我们不能因为删除了结点，而让这棵树变得不满足二叉排序树的特性，所以删除需要考虑多种情况。

如果需要查找并删除如37、51、73、93这些在二叉排序树中是叶子的结点，那是很容易的，毕竟删除它们对整棵树来说，其他结点的结构并未受到影响，如下图所示。

对于要删除的结点只有左子树或只有右子树的情况，相对也比较好解决。那就是结点删除后，将它的左子树或右子树整个移动到删除结点的位置即可，可以理解为独子继承父业。比如下图，就是先删除35和99结点，再删除58结点的变化图，最终，整个结构还是一个二叉排序树。

但是对于要删除的结点既有左子树又有右子树的情况怎么办呢？比如下图中的47结点若要删除了，它的两儿子以及子孙们怎么办呢？

我们仔细观察一下，47的两个子树中能否找出一个结点可以代替47呢？果然有，37或者48都可以代替47，此时在删除47后，整个二叉排序树并没有发生什么本质的改变。

为什么是37和48？对的，它们正好是二叉排序树中比它小或比它大的最接近47的两个数。也就是说，如果我们对这棵二叉排序树进行中序遍历，得到的序列{29,35,36,37,47,48,49,50,51,56,58,62,73,88,93,99}，它们正好是47的前驱和后继。

因此，比较好的办法就是，找到需要删除的结点p的直接前驱（或直接后继）s，用s来替换结点p，然后再删除此结点s，如下图所示。

根据我们对删除结点三种情况的分析：

叶子结点；
仅有左或右子树的结点；
左右子树都有的结点，我们来看代码，下面这个算法是递归方式对二叉排序树T查找key，查找到时删除。

1．程序开始执行，代码第4～7行目的是为了删除没有右子树只有左子树的结点。此时只需将此结点的左孩子替换它自己，然后释放此结点内存，就等于删除了。

2．代码第8～11行是同样的道理处理只有右子树没有左子树的结点删除问题。

3．第12～25行处理复杂的左右子树均存在的问题。

4．第14行，将要删除的结点p赋值给临时的变量q，再将p的左孩子p->lchild赋值给临时的变量s。此时q指向47结点，s指向35结点，如下图所示。

5．第15～18行，循环找到左子树的右结点，直到右侧尽头。就当前例子来说就是让q指向35，而s指向了37这个再没有右子树的结点，如下图所示。

7．第20～23行，如果p和q指向不同，则将s->lchild赋值给q->rchild，否则就是将s->lchild赋值给q->lchild。显然这个例子p不等于q，将s->lchild指向的36赋值给q->rchild，也就是让q->rchild指向36结点，如下图所示。

8．第24行，free(s)，就非常好理解了，将37结点删除，如下图所示。

从这段代码也可以看出，我们其实是在找删除结点的前驱结点替换的方法，对于用后继结点来替换，方法上是一样的。

总结

总之，二叉排序树是以链接的方式存储，保持了链接存储结构在执行插入或删除操作时不用移动元素的优点，只要找到合适的插入和删除位置后，仅需修改链接指针即可。插入删除的时间性能比较好。而对于二叉排序树的查找，走的就是从根结点到要查找的结点的路径，其比较次数等于给定值的结点在二叉排序树的层数。极端情况，最少为1次，即根结点就是要找的结点，最多也不会超过树的深度。也就是说，二叉排序树的查找性能取决于二叉排序树的形状。可问题就在于，二叉排序树的形状是不确定的。

例如{62,88,58,47,35,73,51,99,37,93}这样的数组，我们可以构建如下图左图的二叉排序树。但如果数组元素的次序是从小到大有序，如{35,37,47,51,58,62,73,88,93,99}，则二叉排序树就成了极端的右斜树，注意它依然是一棵二叉排序树，如图8-6-18的右图。此时，同样是查找结点99，左图只需要两次比较，而右图就需要10次比较才可以得到结果，二者差异很大。