Question

我试图在c ++中找到向量中元素的第一个索引。

让我们说你有一个向量：[2,3,4,2,6,7,1,2,6,3]。

我想找到数字6的位置。

因此第6次出现的数字是指数值为4。

是否有可以在C ++中执行此操作的函数？

我在Python中知道，我可以使用list.index（n）方法为我做这件事。

Answer 1

std::vector<int> vct;
//insert value

//use std::find to get iterator
auto itr=std::find(vct.begin(), vct.end(), 6);
if(itr==vct.end())
    return;
auto index=std::distance(vct.begin(), itr);

Answer 2

你需要做这样的事情：

int getIndexOf(std::vector<int> v, int num)
{
    for(std::vector<int>::size_type i = 0; i != v.size(); i++)
    {
        if(v[i] == num)
        {
            return i;
        }
    }
    return -1;
}

编辑：效率肯定是一个考虑因素，也许这可能是一个可行的解决方案。我将矢量中每个项目的索引存储到unordered_multimap中的相应散列值中。注意：这是假设向量的内容不会经常更改 super 。

#include <unordered_map>
#include <algorithm>

typedef std::unordered_multimap<int,int>::const_iterator IntMapIterator;
typedef std::pair<int,int> IntPair;

std::unordered_multimap<int,int> hashValues(const std::vector<int>& vec)
{
    std::unordered_multimap<int,int> hashedValues;
    for(std::vector<int>::size_type i = 0; i != vec.size(); i++)
    {
        hashedValues.emplace(vec[i], i);
    }
    return hashedValues;
}

struct IntPairComparator
{
    bool operator()(const IntPair& left, const IntPair& right) const
    {
        return left.second < right.second;
    }
};

int getEarliestIndex(const std::unordered_multimap<int,int>& hashedValues, int num)
{
    std::pair<IntMapIterator,IntMapIterator> range = hashedValues.equal_range(num);
    IntPair minPair = *std::min_element(range.first, range.second, IntPairComparator());
    return minPair.second;
}

int main(int argc, const char* argv[])
{
    std::vector<int> bigVector;
    // do stuff and fill contents of vector
    std::unordered_multimap<int,int>& hashedValues = hashValues(bigVector);
    int earliestIndex = getEarliestIndex(hashedValues, 6);
}

Answer 3

您可以使用：

InputIterator find (InputIterator beg, InputIterator end, const T& value)

在#include <algorithm>中定义。

用法

假设您有以下向量：

std::vector<int> numberVector;

numberVector.push_back(1);
numberVector.push_back(2);
numberVector.push_back(3);
numberVector.push_back(4);
numberVector.push_back(5);

您可以通过以下方式找到4的索引：

std::vector<int>::iterator position = std::find(
    numberVector.begin(), numberVector.end(), 4
);

然后检查是否找到了：

bool exists = (position != numberVector.end());

如果存在，则可以通过以下方式获取索引：

int index = position - numbVector.begin();

Answer 4

如果你的矢量不是很大，可能你可以使用它。

std::find(vector.begin(), vector.end(), item)!=vector.end() 您将直接获取指向该值的迭代器..

如果矢量太大，您可以使用某些binary_search，lower_bound或upper_bound算法，因为使用此算法可以影响性能。

Answer 5

不，没有明确的功能可以做到这一点，但＃51k指向了正确的方向。如果您有需要，可能必须编写自己的实现，其他人已经提到了其中的一些

Answer 6

为了扩展Geoffrey Tucker的回应，您实际上可以概括为模板函数：

#include <algorithm>
#include <iterator>
#include <vector>

template <typename T=int, class ContainerType=std::vector<T> >
typename std::iterator_traits<typename ContainerType::iterator>::difference_type
get_index_of(const ContainerType& c, const T& t) {
  ContainerType::const_iterator itr = std::find(c.begin(), c.end(), t);
  return (std::distance(c.begin(), itr));
}

请注意，这里，为不在容器中的项返回的索引实际上超过了c.size()的值，其中c是容器（在您的情况下是向量）。这与Geoffrey的实施不同，他返回-1;在这里，我们将它留给容器类型来确定函数的返回类型。

Answer 7

#include <iostream>
#include <vector>

using namespace std;

int find_index( int n, vector<int> & v )
{
  int pos = 0;
  for( const auto i : v ) { if( i == n ) return pos; ++pos; }
  return -1; // not found index
}

int main()
{
  vector<int> v{ 2, 3, 4, 2, 6, 7, 1, 2, 6, 3 };
  cout << find_index( 6, v ) << endl;
}

在C ++中返回向量中元素的第一个索引

7 个答案:

用法