数据结构与算法--关于查找的常见算法

1. 静态查找

静态查找是“真正的查找”。因为在静态查找过程中仅仅是执行“查找”的操作，即：
（1）查看某特定的关键字是否在表中（判断性查找）
（2）检索某特定关键字数据元素的各种属性（检索性查找）。
这两种操作都只是获取已经存在的一个表中的数据信息，不对表的数据元素和结构进行任何改变，这就是所谓的静态查找。

常见的静态查找：顺序查找、插值查找、二分查找、裴波拉契查找

1.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;
}

在顺序查找时，我们可以对其添加哨兵，数组a的第0个位置作为哨兵，来存储查找的值

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

1.2 折半查找

折半查找又叫二分查找，也是常有的查找算法。

折半查找的前提是线性表中的记录必须是关键码有序（通常是从小到大），表必须采用顺序存储。

折半查找思路：

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

// 假设 数组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;
}

1.3 插值查找

假设数据a[11] = {0, 1, 16, 24, 35, 47, 59, 62, 73, 88, 99}，有折半查找key = 16时，low = 1，height = 10，则a[low] = 1，a[height] = 99，需要查找四次

折半查找的公式如下：

我们对其优化，mid等于最低下标low加上最高下标height与最低下标low差值的一半。

然后将1/2改成下面的形式

那么，

对2.377取整，则mid = 2，我们只需要查找两次就能得到结果。这就是插值查找。

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.4 裴波拉契查找

裴波拉契查找需要依靠裴波拉契数列裴波拉契

裴波拉契查找公式：

• mid = low + F[k-1] - 1
• key < a[mid]，k = k - 1
• key > a[mid]，k = k - 2

假设有下面的一个数列：

F为裴波拉契数列，假设查找 n = 10，k = 99

首先n = 10， F[6] < n < F[7]，,所以计算得出k = 7。 找出n位于斐波那契数列的位置。

F[7] = 13, 而a最大仅有a[10]。后面的a[11],a[12] 是未赋值。不能构成有序数列。所以将后续的2个元素赋值 a[11] = a[12] = a[10] = 99。

• 第一次查找
  low = 1，k = 7，
  mid = low + F[k-1] - 1 = 1 + F[7-1] - 1 = 1 + 8 - 1 = 8
key > a[8] (99 > 73)
k = k - 2 = 7 - 2 = 5
low = mid + 1 = 9

• 第二次查找
  low = 9，k = 5，
  mid = low + F[k-1] - 1 = 9 + F[5-1] - 1 = 9 + 3 - 1 = 11
key > a[11] (99 = 99)
mid > n ,11>10，则返回n。所以返回10
  表示找到key =99 在数组a中的位置，在10这个位置

思路：

1. 先计算n位于斐波拉契数列的位置
2. 将数组a不满的位置补全值
3. 循环 low <= high
4. mid = low+F[k-1]-1;
	4.1 key < a[mid]，high = mid-1；k = k - 1
	4.2 key > a[mid]，low = mid+1；k = k - 2
	4.3 判断 mid <= n，返回 mid 或者 n

代码实现：

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

2. 动态查找（二叉搜索树）

动态查找：它更像是一个对表进行创建、扩充、修改、删除的过程。

动态查找的过程中对表的操作会多两个动作：
（1）首先也有一个“判断性查找”的过程，如果某特定的关键字在表中不存在，则按照一定的规则将其插入表中；
（2）如果已经存在，则可以对其执行删除操作。

常见的动态查找（表）：各种树（二叉搜索树、AVL、B/B+树、红黑树等等）、哈希表

接下来来了解一下二叉排序树，假设有以下一组数a[62，88，58，47，35，73，51，99，37，93]。当我们用顺序存储的线性表进行存储时，假设要查找key = 93时，要遍历很多次才能找到。

那么吗，我们借助二叉树来存储，在存储的过程中，比双亲节点小的，存储到左子树，比双亲节点大的，存储到右子树，可以通过比较缩小查找范围，其实这样存储的二叉树就是二叉排序树。

二叉排序树又称为二叉查找树，它或者是一个空树，或者具有以下性质的二叉树：

• 若左子树不为空，则左子树上所以的节点均小于其根结构的值
• 若右子树不为空，则右子树上所以的节点均小于其根结构的值
• 其左右子树分别是二叉排序树

对上面的数组，以二叉排序树的形式存储，如下：

2.1 查找数据

假设查找key = 93，根据上图，则：

• 第一次，62 < 93，缩小查找范围到其右子树
• 第二次，88 < 93，缩小查找范围到其右子树
• 第三次，99 > 93，缩小查找范围到其左子树
• 第四次，93 = 93，成功，返回true

那么代码怎么实现呢？先来定义一下二叉树的二叉链表结点结构

#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;

查找思想：

利用递归，比较key 和 节点data的值，相等，则返回true，
大于，则递归右子树，
小于，则递归左子树

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.2 插入数据

当向二叉搜索树中插入某个key时，要先进行查找

插入思路：

1. 先查找插入的值，是否存在二叉树中，存在，则插入失败
2. 不存在，则插入到合适的位置
	2.1 初始化节点，并用 key 对其 data 赋值，左右子树为 NULL
	2.2 通过最后查找返回的节点 P进行比较，
		key < p，新节点插入为左孩子
		key > p，新节点插入为右孩子

Status InsertBST(BiTree *T, int key) {
    
    BiTree p,s;
    //✅ 查找插入的值是否存在二叉树中;查找失败则->
    if (!SearchBST(*T, key, NULL, &p)) {
        
        //✅ 初始化结点s,并将key赋值给s,将s的左右孩子结点暂时设置为NULL
        s = (BiTree)malloc(sizeof(BiTNode));
        s->data = key;
        s->lchild = s->rchild = NULL;
        
        //✅ 比较，插入
        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;
}

2.3 删除数据

二叉搜索树的删除，可以分为三种情况：

• 删除的数据是叶子节点，比如上图中的 37，51，73，93，这样的节点直接删除即可，不会影响二叉搜索树的结构
• 删除的数据只有左子树或者右子树，比如58，35，99，先删除，然后在将其左子树或者右子树，连接到被删除节点的双亲节点的左子树或者右子树上。
• 删除的数据，既有左子树，又有右子树，比如47。

那么第三种这样的节点怎么删除呢？我们来分析一下：

1. 定义两个变量temp 和 p 都指向 被删除节点 47.
2. 定义 s 指向待删除节点的左子树
3. 在待删除节点的左子树中，从右边找到直接前驱（中序遍历 29 ， 35，37，47---）
4. 用 temp  保存好直接前驱的双亲节点

此时如下图：

5. 将要删除节点的 p 的数据赋值成 s->data，即：将37 赋值给到 p，替换 47
6. 判断，如果 temp 不等于 p， 将 s 的左子树赋值给 temp 的右子树
7. 判断，如果 temp 等于 p， 将 s 的左子树赋值给 temp 的左子树
8. 释放  s 指向的节点 

最终如下：

代码实现：

Status Delete(BiTree *p){

    BiTree temp,s;
    if((*p)->rchild == NULL){
       
        //✅ 情况1: 如果当前删除的结点,右子树为空.那么则只需要重新连接它的左子树(删除叶子节点时，其左右孩子为NULL)
        //✅ 将结点p临时存储到temp中;
        temp = *p;
        //✅ 将p指向到p的左子树上;
        *p = (*p)->lchild;
        //✅ 释放需要删除的temp结点;
        free(temp);
        
    }else if((*p)->lchild == NULL){
        
        //✅ 情况2:如果当前删除的结点,左子树为空.那么则只需要重新连接它的右子树(删除叶子节点时，其左右孩子为NULL)
        //✅ 将结点p存储到temp中;
        temp = *p;
        //✅ 将p指向到p的右子树上;
        *p = (*p)->rchild;
        //✅ 释放需要删除的temp结点
        free(temp);
    }else{
        
        //✅ 情况③:删除的当前结点的左右子树均不为空;
       
        //✅ 1. 将结点p存储到临时变量temp, 并且让结点s指向p的左子树
        temp = *p;
        s = (*p)->lchild;
      
        //✅ 2. 将s指针,向右到尽头(目的是找到待删结点的前驱)
        //-在待删除的结点的左子树中,从右边找到直接前驱
        //-使用`temp`保存好直接前驱的双亲结点
        while (s->rchild) {
            temp = s;
            s = s->rchild;
        }
        
        //✅ 3. 将要删除的结点p数据赋值成s->data;
        (*p)->data = s->data;
        
        //✅ 4. 重连子树
        //✅ 如果temp 不等于p,则将S->lchild 赋值给temp->rchild
        //✅ 如果temp 等于p,则将S->lchild 赋值给temp->lchild
        if(temp != *p)
            temp->rchild = s->lchild;
        else
            temp->lchild = s->lchild;
        
        //✅ 5. 删除s指向的结点; free(s)
        free(s);
    }
    
    return  TRUE;
}

//4.查找结点,并将其在二叉排序中删除;
/* 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点, */
/* 并返回TRUE；否则返回FALSE。 */
Status DeleteBST(BiTree *T,int key)
{
    //✅ 1. 不存在关键字等于key的数据元素
    if(!*T)
        return FALSE;
    else
    {
        //✅ 2. 找到关键字等于key的数据元素
        if (key==(*T)->data)
            return Delete(T);
        else if (key<(*T)->data)
            //✅ 3. 关键字key小于当前结点,则缩小查找范围到它的左子树;
            return DeleteBST(&(*T)->lchild,key);
        else
            //✅ 3. 关键字key大于当前结点,则缩小查找范围到它的右子树;
            return DeleteBST(&(*T)->rchild,key);
        
    }
}