数据结构和算法（17）- 静态查找

一.顺序查找

从表的一端开始，依次将记录的关键字和给定值进行比较，若某个记录的关键字和给定值相等，则查找成功；反之，扫描整个表后，仍未找到相等的记录，则查找失败。

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.顺序查找-引入哨兵对象

数据从第一位开始存储，第0位存储要查找的值，从最后一位开始比较，如果返回0，表示查找失败。

引入哨兵，免去了查找过程中每一步都要检测整个表是否查找完毕，实践证明，这个改进能使顺序查找在数据量大于1000时，进行一次查找所需的平均时间几乎减少一半。

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

二.折半查找

折半查找又称二分查找，效率比较高，但是要求线性表必须采用顺序存储结构，而且表中按关键字有序排列。

查找过程：

从表的中间记录开始，如果给定值和中间记录的关键字相等，则查找成功;如果给定值大于或者小千中间记录的关键字，则在表中大于或小千中间记录的那一半中查找，这样重复操作，直到查找成功，或者在某一步中查找区间为空，则代表查找失败。

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

三.插值查找

数组有序，思想和折半查找相同，只是每次的查找范围不再是一半

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

四.斐波拉契查找

利用斐波拉契数组，不断调整范围进行比较

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[]) {
    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;
}

六.输出

Hello, 静态查找!
顺序查找:100
顺序查找_哨兵:1 
折半查找:7 
插值查找:7 
斐波拉契查找:10 
斐波拉契查找:6