关于查找有哪些常见的算法?

查找算法有两种:一种只作查找操作,我们称之为静态查找。一种在查找过程种同时插入或删除数据元素,我们称之为动态查找。

静态查找

它的功能如下:

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

常见的查找方法有:顺序查找、折半查找、插值查找、斐波那契查找等,容我细细讲来。

顺序查找

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

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

代码如下:

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

上面的代码是可以优化的,因为for循环每次都要比较 i<=n,我们可以减少这步,只需要将给定值存在起始位,从末尾开始查起。代码如下:

//顺序查找_哨兵
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;
}

顺序查找的时间复杂的是O(n)。

折半查找

⼜称为二分查找,它的前提是线性表中的记录必须是关键码有序(通常是从小到⼤有序),即线性表必须采⽤顺序存储。

折半查找的基本思想是:

  1. 在有序表中,取中间记录作为⽐较对象,若给定值与中间记录的关键字相等则查找成功;
  2. 若给定值小于中间的记录关键字,则在中间记录的左半区继续查找;
  3. 若给定值大于中间的记录关键字,则在中间记录的右半区继续查找;
  4. 不断重复以上的过程,直到查找成功,或所有查找区域无记录,查找失败为止。
折半查找.png

代码如下:

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

顺序查找的时间复杂的是O(logN)。如果数据不是有序的,还要进行排序,那时间复杂度就比顺序查找要高了。同学们根据实际情况选择哦。

插值查找

折半查找的缺点在于在1-100的范围查找2,会从中间50开始二分,然后循环下去,这样二分次数会比较多。如果查找的表里的数据是比较均匀分布的话,我们可以优化折半查找,这就是要讲的插值查找。

插值查找是根据查找的关键字key与查找表中最⼤和最⼩记录的关键字比较后的查找方法, 其核心就是在于插值的计算公式: (key - a[low]) / (a[high] - a[low])。举个例子,在1-100的范围查找2,会判断2和100的比例k,然后从数组长度*k的位置开始查找。

代码如下:

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

插值查找的时间复杂的是O(logN),但是它在均匀分布的查找表中可以接近O(1)。

斐波拉契查找

插值查找比较适合在均匀分布的查找表中,而想在非均匀分布的查找表中优化折半查找,就得使用我们的斐波那契查找了。

你或许想问了,它比折半查找优在哪里呢?使用折半查找在1-100的范围查找2和50的比较次数是不同的,然而斐波那契查找可以让查找2和50的比较次数大致相同。说到这里我又想到了著名面试题:鹰蛋问题、爬楼问题(想要了解的可以去搜索一下)。这里的斐波那契查找也有点动态规划的意思,它利用了斐波那契数列的特性,越大的前一个值和后一个值的比例越接近黄金分隔比。

斐波那契数列:1、1、2、3、5、8、13、21、34 ...

将二分改为黄金分割,这就是斐波那契的核心思想。代码如下:

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

斐波那契查找的时间复杂的是O(logN),它的优化在于平均了折半查找的每次相差较大的耗时。

辅助代码

#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等 */

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

输出结果

输出结果.png

动态查找

它的功能如下:

  1. 查找时插⼊数据元素;
  2. 查找时删除数据元素。

二叉排序树

动态查找要使用到二叉排序树(Binary Sort Tree)。它又称为二叉查找树. 它或者是一棵空树.或者是一棵具有下列列性质的二叉树。

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

二叉排序树结构定义

//结点结构
typedef  struct BiTNode
{
    //结点数据
    int data;
    //左右孩子指针
    struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;

查找操作

  1. 递归查找二叉排序树T中,是否存在key;
  2. 指针f指向T的双亲,其初始值为NULL;
  3. 若查找成功,则指针p指向该数据元素的结点,并且返回TRUE;
  4. 若指针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);
    }
}

插入操作

  1. 执行查询操作,查询到有数据返回FALSE
  2. 没有数据则根据大小判断插入为左孩子或者右孩子。
Status InsertBST(BiTree *T, int key) {
    
    BiTree p,s;
    //1.查找插入的值是否存在二叉树中;查找成功则返回False
    if (SearchBST(*T, key, NULL, &p)) {
        return FALSE;
    }
    //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;
}

删除操作

删除和插入一样也是需要先做查询操作,查询到没有该数据时返回FALSE。

有该数据则进行删除判断,二叉排序树删除结点会出现的3种情况:

  1. 删除叶⼦结点 (直接删除即可)。
  2. 删除仅有左或者右⼦树的结点 (将子树上位);
  3. 删除左右⼦树都有的结点p(找到中序遍历中待删除结点的前驱结点s,将s的值赋值给p,然后s的位置由它的左子树代替)。
//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);
        }
    }
}

辅助代码

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

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

输出结果

输出结果.png

如有不对的地方,请指正,谢谢您的阅读~

推荐阅读更多精彩内容