c++: binary search/二分法查找

查找方法

• 最简单的查找——顺序查找，即从数组第一个元素开始，一个一个顺序查下去直到找到或查到最后一个元素为止。
• 数据排列有序时，可以采用对半查找（binary search）。算法的执行效率比顺序查找高。
• 散列查找：散列（hash）查找是最快的查找方法。前文介绍的两种查找方法都是将需查找的关键字值与表中的数据元素的关键字值进行比较而达到查找的目的。如果能找到一个函数 f(key)，将关键字经过函数的运算转换为数据表中的位置，直接将数据元素插入在该位置上。在查找中可直接取用该位置的数据元素。这样的组织称为散列，利用散列技术查找的方法称为散列查找，散列查找是一种直接查找。亦用音译称哈希查找。

二分查找也属于顺序表查找范围，二分查找也称为折半查找。二分查找(有序)的时间复杂度为O(LogN)。

那么什么是二分查找呢？二分查找的基本思想是， 在有序表中，取中间记录作为比较对象，若给定值与中间记录的关键字相等，则查找成功；若给定值小于中间记录的关键字，则在中间记录的左半区继续查找；若给定值大于中间记录的关键字，则在中间记录的右半区继续查找。不断重复上述过程，直到找到为止。

从二分查找的定义我们可以看出，使用二分查找有两个前提条件：

1，待查找的列表必须有序，这里使用递归快排来使产生的随机无序数组有序。

2，必须使用线性表的顺序存储结构来存储数据。

下面是c++实现代码。

#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;

void Qsort(std::vector &set, int low, int high);
int Partition(std::vector &set, int low, int high);
void quickSort(std::vector &s, int l, int r);
bool binaryfind(const std::vector &set, const int x, int low, int high,int &position);


void Qsort(std::vector &set, int low, int high)
{
    if(low < high)
    {
        int pivot = Partition(set, low, high);
        Qsort(set, low, pivot - 1);
        Qsort(set, pivot + 1, high);
    }
}

int Partition(std::vector &set, int low, int high)
{
    int pivotkey=set.at(low);
    while (low < high)
    {
        while (low < high && set.at(high) <= pivotkey)
            high--;
        set.at(low) = set.at(high);
        while (low < high && set.at(low) >= pivotkey)
            low++;
        set.at(high) = set.at(low);
    }
    set.at(low) = pivotkey;
    return low;
}

void quickSort(std::vector &s, int l, int r)
{
    if(l= pivot)
                high--;
            if(low &set, const int x, int low, int high,int &position)
{
    while (low <= high && set[position] != x)
    {
        if (x < set[position])
        {
            low = position + 1;
        }
        else if (x > set[position])
        {
            high = position - 1;
        }
        else
        {
            break;
        }
        position = (low + high) / 2 ;

    }
    if (set.at(position) == x)
    {
        return true;
    }
    else
    {
        return false;
    }
}

int main(int argc, char *argv[])
{
    std::vector set;
    set.push_back(24);
    set.push_back(3);
    set.push_back(5);
    set.push_back(4);
    set.push_back(6);
    set.push_back(1);
    set.push_back(0);
    set.push_back(7);
    set.push_back(8);
    set.push_back(10);
    set.push_back(20);
    set.push_back(9);
    set.push_back(11);

//    item: 24  0
//    item: 20  1
//    item: 11  2
//    item: 10  3
//    item: 9   4
//    item: 8   5
//    item: 7   6
//    item: 6   7
//    item: 5   8
//    item: 4   9
//    item: 3   10
//    item: 1   11
//    item: 0   12
//    quickSort(set, 0, set.size()-1);

    Qsort(set, 0, set.size()-1);
    while(ros::ok)
    {

        for(int i =0; i < set.size(); i++)
        {
            std::cout << "item: " << set.at(i) << std::endl;
        }

        int str;
        std::cin >> str;
        int item = (int)str;
        int position;
        bool inside = binaryfind(set, item, 0, set.size(), position);

        std::cout<::iterator iter = set.begin()+position + 1 ;
            set.insert(iter, (int)item);
        }
        else
        {
            std::cout << "## item: " << item << "  in set, inside status: "<< boolalpha <