数据结构与算法--常用的一些查找方法

1、查找

查找(Searching): 就是根据给定的某个值,在查找表中确定⼀一个其关键字等于给定值 的数据元素

查找表(Search Table)是由同⼀一类型的数据元素(记录)构成的集合

关键字(Key)是数据元素中某个数据项的值.⼜又称为键值. ⽤用它可 以表示⼀一个数据元素,也可以标识⼀一个记录的某个数据项(字段). 我们称为关键码 若关键字可以唯⼀一地标识⼀一个记录, 则称此关键字为主关键字 (Primary Key) 对于那些可以识别多个属于元素(记录)的关键字,我们称为次关键 字(Secondary Key)

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

swift

//1.顺序查找
//a为数组,n为查找的数组个数,key为要查找的关键字;
func Sequential_Search(_ a:Array<Int>, key:Int) -> Int {
    for i in 0 ..< a.count {
        if a[i] == key {
            return i
        }
    }
    return -1;
}

//2.顺序查找_哨兵
func Sequential_Search2(_ a:Array<Int>, key:Int) -> Int {
    var i = 0;
    var array = [0] + a
    //设置array[0]为关键字值,称为'哨兵'
    array[0] = key
    i = a.count
    repeat {
        i -= 1
    } while (array[i+1] != array[0])
    return i
}

//3.折半查找算法
//假设数组a,已经是有序的(从小到大)
func Binary_Search(_ a:Array<Int>, key:Int) -> Int {
    //定义最低下标为记录首位
    //定义最高下标为记录末位
    var low = 0, high = a.count - 1
    while low <= high {
        let 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 -1
}
//4. 插值查找
func Interpolation_Search(_ a:Array<Int>, key:Int) -> Int {
    //定义最低下标为记录首位
    //定义最高下标为记录末位
    var low = 0, high = a.count - 1
    while low <= high {
        let 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 -1
}

//5.斐波拉契查找
func Fibonacci_Search(_ a:Array<Int>, key:Int) -> Int {
    //定义最低下标为记录首位
    //定义最高下标为记录末位
    var low = 0, high = a.count - 1, k = 0
    var array = a
    //1.计算n为斐波拉契数列的位置;
    while (a.count > f[k] - 1) {
        k += 1
    }
    //2.将数组a不满的位置补全值;
    for _ in a.count ..< f[k] - 1 {
        array.append(a.last!)
    }
    //3.
    while (low <= high) {
        //计算当前分隔的下标;
        let mid = low + f[k-1] - 1
        if key < array[mid] {
            //若查找的记录小于当前分隔记录;
            //将最高下标调整到分隔下标mid-1处;
            high = mid - 1
            //斐波拉契数列下标减1位;
            k = k - 1
        } else if key > array[mid] {
            //若查找的记录大于当前的分隔记录;
            //最低下标调整到分隔下标mid+1处
            low = mid + 1
            //斐波拉契数列下标减2位;
            k = k - 2
        } else {
            if mid < a.count {
                //若相等则说明,mid即为查找的位置;
                return mid
            } else {
                //若mid>n,说明是补全数值,返回n;
                return a.count - 1
            }
        }
    }
    return -1
}

let array = [1,16,24,35,47,59,62,73,88,99]

print("顺序查找:\(Sequential_Search(array, key: 99))")
print("顺序查找_哨兵:\(Sequential_Search2(array, key: 1))")
print("折半查找:\(Binary_Search(array, key: 62))")
print("插值查找:\(Binary_Search(array, key: 62))")
//5.斐波拉契查找
//斐波拉契数列计算;
var f = Array<Int>()
f.append(1)
f.append(2)
for i in 2 ..< 50 {
    f.append(f[i-1] + f[i-2])
}
print("斐波拉契查找:\(Fibonacci_Search(array, key: 99))")