Question

我知道,我们在双轨搜索中使用<代码>,同时使用;=终端。我想到的是,我们能像这里的法典那样,使用<条码>。我找不到可能失败的例子。

class BinarySearch {
public:
    int bin_search(vector<int>& nums, int target) {
        int count = nums.size();
        int front = 0;
        int end = count - 1;

        if(nums[0]==target){return 0;}
        while(front!=end){

            int mid = (end + front)/2;
            // cout<<mid<<endl;
            if(nums[front] == target){return front;}
            else if(nums[end] == target){return end;}


            else if(nums[mid]==target){return mid;}

            else if(nums[mid]<target){
                front = mid+1;
            }

            else if(nums[mid]>target){
                end = mid - 1;
            }
        }

        return -1;
    }
};

自2006年以来我在逐处检查南半球和南半球的状况,但我不认为这一法典应该失败。我在试办案时尝试过,我正在得到正确的答案,但我问,如果我错过了它可能失败的任何角落。

Answer 1

你的解决办法有一些次要问题,可能导致不正确的结果。

我对这段话作了解释,然后,我要描述我为何每次改动。

std::size_t bin_search(std::vector<int> const& nums, int target) {

以<代码>const& 取走你的集装箱。
返回<代码>std:size_t int;int通常是在64台轨道机上安装的32台轨道,2^31-1号尺寸的矢量可由现代计算机处理。您将<代码>int退回,从而限制您的算法可处理的内容。在64台借机上,size_t为64台借机,如果不是几个世纪的话,将足以处理任何<代码>d:至少在今后几十年里<>。

auto front = nums.begin(); auto end = nums.end(); by using iterators instead of indexes and by using half-open intervals, a bunch of benefits are produced.

Half open intervals handle empty intervals very naturally - with the start and end being equal.

激光器,而不是索引,都比较快,使你无法把贵重空间与你的隔开空间。

我们还削减了“遏制零件”。空洞病媒在这里死亡,你的算法应当正确,而不在此进行硬编码核对。

  while(front!=end){

我们这样做。注:!=将予以罚款。

    auto mid = front + (end-front)/2;

这是微妙的区别。我们不增加终点和前线的指数,而是把二者分开,这可能导致超额问题,而是把两者的距离(限制在64个轨道上)减半,并重新推向前线。

由于我们实际上正在使用激光器,这也是合法的,即(很少接触)探测器的消减器会产生距离的成分,可以减半,并补充说,向激光器的回馈会再次产生探测器。

    if (*mid == target) { return mid-nums.begin(); }
    if (*mid < target) { front = std::next(mid); continue; }
    if (*mid > target) { end = mid; continue; }

我在此改变了撤离条件。我只检查中间点。

We do a 3 way comparison. This is useful because I can call <=> in more modern version of C++ and get the value in one step.

  }
  return static_cast<std::size_t>(-1);
}

由此形成了这一法典:

std::size_t bin_search(std::vector<int> const& nums, int target) {
  auto front = nums.begin();
  auto end = nums.end();
  while(front!=end){
    auto mid = front + (end-front)/2;

    if (*mid == target) { return mid-nums.begin(); }
    if (*mid < target) { front = std::next(mid); continue; }
    if (*mid > target) { end = std::prev(mid); continue; }
  }
  return static_cast<std::size_t>(-1);
}

或 C++:

std::size_t bin_search(std::vector<int> const& nums, int target) {
  auto front = nums.begin();
  auto end = nums.end();
  while(front!=end){
    auto mid = front + (end-front)/2;

    auto cmp = *mid <=> target;
    if (cmp == 0) { return mid-nums.begin(); }
    if (cmp < 0) { front = std::next(mid); continue; }
    if (cmp > 0) { end = mid; continue; }
  }
  return static_cast<std::size_t>(-1);
}

最后,我注意到,我回到<代码>中边(),这是范围要素的指数。

......

回到基于你的指数的代码上,奇怪的是,在范围上存在问题,因为你的代码似乎没有使用半开放的间隔。您的法典认为它采用封闭的间隔,nums[end]仍然是你范围的一部分。

半开放的间隔装有左边栅栏,但不包括右边栅栏。如果使用算法的话,算法的炉.就会.。

友情链接