算法交作业之查找

前言：

刚刚写了一篇发泄文，果不其然，心里面舒服很多。既然心情舒畅了，那就继续写下去吧。

假定：

我们假定查找的数据唯一存在，数组中没有重复的数据存在。

普通查找：

适用情景：
无特征，需要遍历整个范围才可以确定。

#include <iostream>
#include <assert.h>
//普通的查找算法。
template<unsigned n>
int Find_Array(const int(&arr)[n], const int& value){
//使用数组类型引用和模版。
    //查找成功返回下标，否则返回-1.
    if (arr == nullptr || n == 0)
        return -1;
    for (unsigned index = 0; index < n;++index)
    if (arr[index] == value)
        return index;
    return -1;
}
//实现为类模版
template<unsigned n,typename T>
int Find_nArray(const T(&arr)[n], const T& value){
    if (arr == nullptr || n == 0)
        return -1;
    for (unsigned index = 0; index < n;++index)
    if (arr[index] == value)
        return index;
    return -1;
}
int main(){
    int arr[10] = { 1, 2, 3, 4, 5 };
    assert(Find_Array(arr, 10) == -1);
    int arr2[3] = { 1, 2, 3 };
    assert(Find_Array(arr2, 2) == 1);
    char arr3[3] = "hi";
    assert(Find_nArray(arr3, ‘i‘)==1);
    system("pause");
    return 0;
}
//时间复杂度为O(n);最少查找1次，最多查找n次。

二分查找：

#include <iostream>
#include <functional>
//查找成功返回下标。
template<unsigned length>
int Binary_Find(const int(&arr)[length], const int& value){
    auto beg = 0, end = length - 1;
    while (beg <= end){
        auto mid = beg +((end - beg)>>1);//采用移位运算符。
        if (arr[mid] == value)          
            return mid;
        else if (arr[mid] > value)      
            end = mid - 1;
        else    
            beg = mid + 1;
    }
    return -1;
}
//比较下面的写法
template<unsigned length>
int Binary_Find_(const int(&arr)[length], const int& value){
    auto beg = 0, end = length;//此处的end=length;
    while (beg < end){//对比
        int mid = beg + ((end - beg)>>1);
        if (arr[mid] == value)      
            return mid;
        else if (arr[mid]<value)        
            beg= mid+1;
        else
            end = mid;//对比
    }
    return -1;
}
//递归
int Binary_Find(int* p,int beg,int end,const int& value){
    if (beg < end){
        auto mid = beg + ((end - beg) >> 2);
        if (p[mid] == value)
            return mid;
        else if (p[mid]>value)
            return Binary_Find(p, beg, mid, value);
        else
            return Binary_Find(p, mid + 1, end, value);
    }
    return -1;
}
//用函数模版实现
template<unsigned length,typename T>
int Binary_Find(const T(&arr)[length], const T& value){
    auto beg = 0, end = length;
    equal_to<T> is_equal; //标准库的可调用对象。
    greater<T> is_greater;
    while (beg<end){
        auto mid = beg + ((end - beg) >> 1);
        if (is_equal(arr[mid], value))
            return mid;
        else if (is_greater(arr[mid], value))
            end = mid;
        else
            beg = mid + 1;
    }
    return -1;
}
int main(){
    int arr[5] = { 1, 2, 3, 4, 5 };
    //std::cout << Binary_Find(arr, 5)
    std::cout<<Binary_Find(arr,0,5,99);
    system("pause");
    return 0;
}

总结：

突然好累，所以留待下次继续补充吧。
有机会会补充二叉树中的递归查找和哈希表中的查找和STL中的查找算法的使用。