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

静态查找

顺序查找

顺序查找又称为线性查找，它的查找过程；从表中的第一个（或最后一个）记录开始，逐个进行记录关键字和给定值比较。

代码实现

  //顺序查找
int Sequential_Search(int *a,int n,int key){
 for (int i = 1; i <= n; i++)
 {
  if (a[i] == key)
  {
   return i;
  }
 }
 return 0;
}

顺序查找预留第 0 个位置为要查找的数据项，进行倒序查找，可以避免索引越界的问题

int Sequential_Search2(int *a,int n,int key){
 
    int i;
    a[0] = key;
    i = n;
    while(a[i] != key){
     i--;
    }
    return i;
}

二分查找

二分查找的前提是关键值必须有序,线性表必须采用顺序存储。
二分查找的基本思想是：

在有序表中，取中间记录作为比较对象，若给定值与中间记录的关键字相等则查找成功；
若给定值小于中间的关键字，则在中间记录的左半区域；
若给定值大于中间的关键字，则在中间记录的右半区域；
求中间值公式： $mid = (left + right) / 2$

代码实现

int search(int* nums, int numsSize, int target){
    int left,middle,right;
    left = 0;
    right = numsSize-1;
    while(left<=right) {
        middle = (left+right)/2;
        if(nums[middle] > target) {
            right = middle-1;
        } 
        else if(nums[middle] < target) {
            left = middle+1;
        } 
        else if(nums[middle] == target){
            return middle;
        }
    }
    return -1;
}

插值查找

插值查找基于二分查找，将查找点的选择改进为自适应选择，提高查找效率。除要求查找表是顺序存储的有序表外，还要求数据元素的关键字在查找表中均匀分布。
求查找点公式: $mid = (key - a[low]) / (a[high] - a[low])$

代码实现

int Binary_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])
 {
  high = mid = 1;
 }else if(key > a[mid]){
  low = mid + 1;
 }else{
  return mid;
 }
}
return 0;
}

斐波那契查找

斐波那契搜索就是在二分查找的基础上根据斐波那契数列进行分割的。

在斐波那契数列找一个等于略大于查找表中元素个数的数 $F(n)$ ，将原查找表扩展为长度为 $F(n)$ (如果要补充元素，则补充重复最后一个元素，直到满足 $F(n)$ 个元素)，完成后进行斐波那契分割，即 $F(n)$ 个元素分割为前半部分 $F(n-1)$ 个元素，后半部分 $F(n-2)$ 个元素，找出要查找的元素在那一部分并递归，直到找到。
求查找点公式: $mid =low+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;
    while(n > F[k] - 1){
     k++;
    }

    //补全
    for (int i = n; i < F[k] - 1; i++)
    {
     a[i] = a[n];
    }
     
    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;
}

动态查找

二叉排序树

二叉排序树又称为二叉查找树，

性质

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

代码实现

#define true 1
#define false 0
#define MAXSIZE 100

typedef int bool;

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

//二叉排序树--查找
/*
 递归查找二叉排序树T中,是否存在key;
 指针f指向T的双亲,器初始值为NULL;
 若查找成功,则指针p指向该数据元素的结点,并且返回TRUE;
 若指针p指向查找路径上访问的最后一个结点则返回FALSE;
 */
bool 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);  /*  在右子树中继续查找 */
}

//二叉排序树-插入
/*  当二叉排序树T中不存在关键字等于key的数据元素时， */
/*  插入key并返回TRUE，否则返回FALSE */
bool 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,并重接它的左或者右子树;
bool 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;
}

//查找结点,并将其在二叉排序中删除;
/* 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点, */
/* 并返回TRUE；否则返回FALSE。 */
bool 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);
        
    }
}