C++11写算法之二分查找

同样的，二分查找很好理解，不多做解释，要注意二分查找的list必须是排好序的。

这里实现了两种二分查找的算法，一种递归一种非递归，看看代码应该差不多是秒懂。想试验两种算法，改变一下findFunc函数指针（auto findFunc = RecursionBinaryFind; //BinaryFind ）即可。

时间复杂度：O(lgn)

空间复杂度：O(1)

除了顺序查找和二分查找，还有一些需要借助某些数据结构才能进行查找的算法，例如：分块查找，二叉排序树查找，哈希查找，B树/B+树/B*树查找等，这些算法的重点更偏向于数据结构本身，因而将放在数据结构部分进行示例。

show me the code ！

// #if __cplusplus < 201103L 
// #error "must be compiled under c++11 support platform!!!"
// #endif
#include <iostream>
#include <algorithm>
#include <iterator>
#include <cassert>
using namespace std;

//WARNING : input varList of function RecursionBinaryFind must be sorted!!!
int RecursionBinaryFindImp(const int varList[], const int begin,const int end, const int target)
{
    if (!varList || begin > end)
    {
        return -1;
    }
    int index = -1;
    int mid = (begin + end) >> 1;

    if (target == varList[mid])
    {
        index = mid;
    }
    else if (target < varList[mid])
    {
        index = RecursionBinaryFindImp(varList,begin,mid - 1,target);
    }
    else if (target > varList[mid])
    {
        index = RecursionBinaryFindImp(varList, mid + 1, end, target);
    }

    return index;
}
int RecursionBinaryFind(const int varList[], const int size, const int target)
{
    if (!varList || size < 0)
    {
        return -1;
    }
    return RecursionBinaryFindImp(varList,0,size-1,target);
}

//WARNING : input varList of function SequentialFind must be sorted!!!
int BinaryFind(const int varList[], const int size, const int target)
{
    if (!varList || size < 0)
    {
        return -1;
    }
    int index = -1;
    int begin = 0;
    int end = size - 1;
    int mid = (begin + end) >> 1;
    while (begin<end)
    {
        if (target == varList[mid])
        {
            break;
        }else if (target < varList[mid])
        {
            end = mid - 1;
        }else if (target > varList[mid])
        {
            begin = mid + 1;
        }
        mid = (begin + end) >> 1;
    }
    index = mid;
    return index;
}

void test()
{
    //case counter
    int testCase = 0;
    //find function object
    auto findFunc = RecursionBinaryFind; //BinaryFind
    //show case result lambda function
    auto showFunc = [&testCase](){cout << "case[" << testCase++ << "] ok... "<<endl; };

    cout << "test begin : " << endl << endl;

    //case empty list
    {
        assert(-1 == findFunc(nullptr, 0, 0));
        showFunc();
    }
    //case wrong list size
    {
        const int testList[] = { -12, -3, 0, 1, 2, 3, 12, 34, 56 };
        assert(-1 == findFunc(testList, 0, 0));
        showFunc();
    }
    //case not found
    {
        const int testList[] = { -12, -3, 0, 1, 2, 3, 12, 34, 56 };
        const int size = sizeof(testList) / sizeof(int);
        const int target = -33;
        assert(-1 == findFunc(testList, 0, 0));
        showFunc();
    }
    //case found at begin position
    {
        const int testList[] = { -12, -3, 0, 1, 2, 3, 12, 34, 56 };
        const int size = sizeof(testList) / sizeof(int);
        const int target = -12;
        assert(0 == findFunc(testList, size, target));
        showFunc();
    }
    //case found at random position
    {
        const int testList[] = { -12, -3, 0, 1, 2, 3, 12, 34, 56 };
        const int size = sizeof(testList) / sizeof(int);
        const int target = 1;
        assert(3 == findFunc(testList, size, target));
        showFunc();
    }
    //case found at end position
    {
        const int testList[] = { -12, -3, 0, 1, 2, 3, 12, 34, 56 };
        const int size = sizeof(testList) / sizeof(int);
        const int target = 56;
        assert(size - 1 == findFunc(testList, size, target));
        showFunc();
    }

    cout <<endl<< "test done ! " << endl << endl;
}

int main(int argc, char* argv[])
{
    test();
    return 0;
}