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 -;
    }
    int index = -;
    int mid = (begin + end) >> ;

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

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

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

void test()
{
    //case counter
    int testCase = ;
    //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(- == findFunc(nullptr, , ));
        showFunc();
    }
    //case wrong list size
    {
        const int testList[] = { -, -, , , , , , ,  };
        assert(- == findFunc(testList, , ));
        showFunc();
    }
    //case not found
    {
        const int testList[] = { -, -, , , , , , ,  };
        const int size = sizeof(testList) / sizeof(int);
        const int target = -;
        assert(- == findFunc(testList, , ));
        showFunc();
    }
    //case found at begin position
    {
        const int testList[] = { -, -, , , , , , ,  };
        const int size = sizeof(testList) / sizeof(int);
        const int target = -;
        assert( == findFunc(testList, size, target));
        showFunc();
    }
    //case found at random position
    {
        const int testList[] = { -, -, , , , , , ,  };
        const int size = sizeof(testList) / sizeof(int);
        const int target = ;
        assert( == findFunc(testList, size, target));
        showFunc();
    }
    //case found at end position
    {
        const int testList[] = { -, -, , , , , , ,  };
        const int size = sizeof(testList) / sizeof(int);
        const int target = ;
        assert(size -  == findFunc(testList, size, target));
        showFunc();
    }

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

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