zoukankan      html  css  js  c++  java
  • STL_算法_查找算法(lower_bound、upper_bound、equal_range)

    C++ Primer 学习中。

    。。

     

    简单记录下我的学习过程 (代码为主)


    //全部容器适用(O(log(n)))    已序区间查找算法


    lower_bound()        //找第一个符合的元素,返回位置迭代器


    upper_bound()        //找最后一个符合的元素。返回位置迭代器


    equal_range()        //找一对迭代器pair(<>,<>)

    关联式容器有等效的成员函数。性能更佳

    #include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<vector>
    #include<algorithm>
    using namespace std;
    
    /*************************************************************************************
    std::lower_bound                 全部排序容器适用                           algorithm
    --------------------------------------------------------------------------------------
    template <class ForwardIterator, class T>
      ForwardIterator lower_bound ( ForwardIterator first, ForwardIterator last,
                                    const T& value );
    
    template <class ForwardIterator, class T, class Compare>
      ForwardIterator lower_bound ( ForwardIterator first, ForwardIterator last,
                                    const T& value, Compare comp );
    
    //eg:
    template <class ForwardIterator, class T>
      ForwardIterator lower_bound ( ForwardIterator first, ForwardIterator last, const T& value )
    {
      ForwardIterator it;
      iterator_traits<ForwardIterator>::difference_type count, step;
      count = distance(first,last);
      while (count>0)
      {
        it = first; step=count/2; advance (it,step);
        if (*it<value)          // or: if (comp(*it,value)), for the comp version
          { first=++it; count-=step+1;  }
        else count=step;
      }
      return first;
    }
    *************************************************************************************/
    
    
    /*************************************************************************************
    std::upper_bound                  全部排序容器适用                           algorithm
    --------------------------------------------------------------------------------------
    template <class ForwardIterator, class T>
      ForwardIterator upper_bound ( ForwardIterator first, ForwardIterator last,
                                    const T& value );
    
    template <class ForwardIterator, class T, class Compare>
      ForwardIterator upper_bound ( ForwardIterator first, ForwardIterator last,
                                    const T& value, Compare comp );
    
    //eg:
    template <class ForwardIterator, class T>
      ForwardIterator upper_bound ( ForwardIterator first, ForwardIterator last, const T& value )
    {
      ForwardIterator it;
      iterator_traits<ForwardIterator>::difference_type count, step;
      count = distance(first,last);
      while (count>0)
      {
        it = first; step=count/2; advance (it,step);
        if (!(value<*it))                 // or: if (!comp(value,*it)), for the comp version
          { first=++it; count-=step+1;  }
        else count=step;
      }
      return first;
    }
    *************************************************************************************/
    
    /*************************************************************************************
    std::equal_range                  全部排序容器适用                           algorithm
    --------------------------------------------------------------------------------------
    template <class ForwardIterator, class T>
      pair<ForwardIterator,ForwardIterator>
        equal_range ( ForwardIterator first, ForwardIterator last, const T& value );
    
    template <class ForwardIterator, class T, class Compare>
      pair<ForwardIterator,ForwardIterator>
        equal_range ( ForwardIterator first, ForwardIterator last, const T& value,
                      Compare comp );
    
    //eg:
    template <class ForwardIterator, class T>
      pair<ForwardIterator,ForwardIterator>
        equal_range ( ForwardIterator first, ForwardIterator last, const T& value )
    {
      ForwardIterator it = lower_bound (first,last,value);
      return make_pair ( it, upper_bound(it,last,value) );
    }
    *************************************************************************************/
    bool mygreater (int i,int j){ return (i>j); }
    
    int main()
    {
        int myints[] = {10,20,30,30,20,10,10,20};
        vector<int> v(myints,myints+8);           // 10 20 30 30 20 10 10 20
        vector<int>::iterator low,up;
    
        sort (v.begin(), v.end());                // 10 10 10 20 20 20 30 30
    
        cout<<"10 10 10 20 20 20 30 30
    ";
    
        low=lower_bound (v.begin(), v.end(), 20); //          ^
        up= upper_bound (v.begin(), v.end(), 20); //                   ^
    
        cout << "20 lower_bound at position " << int(low- v.begin()) + 1 << endl;
        cout << "20 upper_bound at position " << int(up - v.begin()) + 1 << endl;
    
        cout << endl;
    
        /**-------------------------------------------------------------------------------**/
    
        pair<vector<int>::iterator,vector<int>::iterator> bounds;
    
        // using default comparison:
    //  sort (v.begin(), v.end());                              // 10 10 10 20 20 20 30 30
        bounds=equal_range (v.begin(), v.end(), 20);            //          ^        ^
        cout<<"10 10 10 20 20 20 30 30
    ";
        cout << "20 bounds at positions " << int(bounds.first - v.begin());
        cout << " and " << int(bounds.second - v.begin()) << endl;
    
        // using "mygreater" as comp:
        sort (v.begin(), v.end(), mygreater);                   // 30 30 20 20 20 10 10 10
        bounds=equal_range (v.begin(), v.end(), 20, mygreater); //       ^        ^
    
        cout<<endl<<"30 30 20 20 20 10 10 10"<<endl;
    
        cout << "20 bounds at positions " << int(bounds.first - v.begin());
        cout << " and " << int(bounds.second - v.begin()) << endl;
    
        return 0;
    }
    
    /******
    Output:
        10 10 10 20 20 20 30 30
        20 lower_bound at position 4
        20 upper_bound at position 7
    
        10 10 10 20 20 20 30 30
        bounds at positions 3 and 6
    
        30 30 20 20 20 10 10 10
        bounds at positions 2 and 5
    
    */
    

  • 相关阅读:
    LeetCode 485. Max Consecutive Ones
    LeetCode 367. Valid Perfect Square
    LeetCode 375. Guess Number Higher or Lower II
    LeetCode 374. Guess Number Higher or Lower
    LeetCode Word Pattern II
    LeetCode Arranging Coins
    LeetCode 422. Valid Word Square
    Session 共享
    java NIO
    非阻塞IO
  • 原文地址:https://www.cnblogs.com/slgkaifa/p/7338472.html
Copyright © 2011-2022 走看看