sort - vector vector c++




Come scoprire se un elemento è presente in un vettore std::? (12)

È possibile utilizzare la funzione di find , trovata nello spazio dei nomi std , ovvero std::find . Si passa alla funzione std::find l' begin e la end dell'iteratore dal vettore che si desidera cercare, insieme all'elemento che si sta cercando e confrontare l'iteratore risultante alla fine del vettore per vedere se corrispondono o meno.

std::find(vector.begin(), vector.end(), item) != vector.end()

Puoi anche dereferenziare l'iteratore e usarlo normalmente, come qualsiasi altro iteratore.

Tutto quello che voglio fare è verificare se un elemento esiste nel vettore o meno, così posso occuparmi di ogni caso.

if ( item_present )
   do_this();
else
   do_that();

Come altri hanno già detto, usa le funzioni STL std::find o std::find . Ma se stai cercando in vettori di grandi dimensioni e questo ha un impatto sulle prestazioni, potresti voler ordinare il vettore e quindi utilizzare gli binary_search , lower_bound o upper_bound .


Ecco una funzione che funzionerà per qualsiasi contenitore:

template <class Container> 
const bool contains(const Container& container, const typename Container::value_type& element) 
{
    return std::find(container.begin(), container.end(), element) != container.end();
}

Tieni presente che puoi utilizzare 1 parametro del modello perché puoi estrarre il value_type dal contenitore. È necessario il nome di tipo perché Container::value_type è un nome dipendente .


In C ++ 11 puoi usare any_of . Ad esempio se è un vector<string> v; poi:

if (any_of(v.begin(), v.end(), bind2nd(equal_to<string>(), item)))
   do_this();
else
   do_that();

Puoi provare questo codice:

#include <algorithm>
#include <vector>

// You can use class, struct or primitive data type for Item
struct Item {
    //Some fields
};
typedef std::vector<Item> ItemVector;
typedef ItemVector::iterator ItemIterator;
//...
ItemVector vtItem;
//... (init data for vtItem)
Item itemToFind;
//...

ItemIterator itemItr;
itemItr = std::find(vtItem.begin(), vtItem.end(), itemToFind);
if (itemItr != vtItem.end()) {
    // Item found
    // doThis()
}
else {
    // Item not found
    // doThat()
}

Puoi usare std::find da <algorithm> :

std::find(vector.begin(), vector.end(), item) != vector.end()

Questo restituisce un bool ( true se presente, false altrimenti). Con il tuo esempio:

#include <algorithm>

if ( std::find(vector.begin(), vector.end(), item) != vector.end() )
   do_this();
else
   do_that();

Se il tuo vettore non è ordinato, usa l'approccio suggerito da MSN:

if(std::find(vector.begin(), vector.end(), item)!=vector.end()){
      // Found the item
}

Se il tuo vettore è ordinato, usa il metodo binary_search suggerito da Brian Neal:

if(binary_search(vector.begin(), vector.end(), item)){
     // Found the item
}

la ricerca binaria produce prestazioni O (log n) nel peggiore dei casi, il che è molto più efficiente del primo approccio. Per utilizzare la ricerca binaria, è possibile utilizzare qsort per ordinare prima il vettore per garantire che sia ordinato.


Se vuoi trovare una stringa in un vettore:

    struct isEqual
{
    isEqual(const std::string& s): m_s(s)
    {}

    bool operator()(OIDV* l)
    {
        return l->oid == m_s;
    }

    std::string m_s;
};
struct OIDV
{
    string oid;
//else
};
VecOidv::iterator itFind=find_if(vecOidv.begin(),vecOidv.end(),isEqual(szTmp));

Un altro esempio che utilizza operatori C ++.

#include <vector>
#include <algorithm>
#include <stdexcept>

template<typename T>
inline static bool operator ==(const std::vector<T>& v, const T& elem)
{
  return (std::find(v.begin(), v.end(), elem) != v.end());
}

template<typename T>
inline static bool operator !=(const std::vector<T>& v, const T& elem)
{
  return (std::find(v.begin(), v.end(), elem) == v.end());
}

enum CODEC_ID {
  CODEC_ID_AAC,
  CODEC_ID_AC3,
  CODEC_ID_H262,
  CODEC_ID_H263,
  CODEC_ID_H264,
  CODEC_ID_H265,
  CODEC_ID_MAX
};

void main()
{
  CODEC_ID codec = CODEC_ID_H264;
  std::vector<CODEC_ID> codec_list;

  codec_list.reserve(CODEC_ID_MAX);
  codec_list.push_back(CODEC_ID_AAC);
  codec_list.push_back(CODEC_ID_AC3);
  codec_list.push_back(CODEC_ID_H262);
  codec_list.push_back(CODEC_ID_H263);
  codec_list.push_back(CODEC_ID_H264);
  codec_list.push_back(CODEC_ID_H265);

  if (codec_list != codec)
  {
    throw std::runtime_error("codec not found!");
  }

  if (codec_list == codec)
  {
    throw std::logic_error("codec has been found!");
  }
}

Usa find dall'intestazione dell'algoritmo di stl.ho illustrato il suo uso con il tipo int. Puoi utilizzare qualsiasi tipo che ti piace purché sia ​​possibile confrontare per uguaglianza (sovraccarico == se è necessario per la tua classe personalizzata).

#include <algorithm>
#include <vector>

using namespace std;
int main()
{   
    typedef vector<int> IntContainer;
    typedef IntContainer::iterator IntIterator;

    IntContainer vw;

    //...

    // find 5
    IntIterator i = find(vw.begin(), vw.end(), 5);

    if (i != vw.end()) {
        // found it
    } else {
        // doesn't exist
    }

    return 0;
}

Usare Newton C ++ è più facile, autodocumentato e più veloce di con std :: find perché restituisce direttamente un bool.

bool exists_linear( INPUT_ITERATOR first, INPUT_ITERATOR last, const T& value )

bool exists_binary( INPUT_ITERATOR first, INPUT_ITERATOR last, const T& value )

Penso che sia ovvio cosa fanno le funzioni.

include <newton/algorithm/algorithm.hpp>

if ( newton::exists_linear(first, last, value) )
   do_this();
else
   do_that();

template <typename T> bool IsInVector(T what, std::vector<T> * vec)
{
    if(std::find(vec->begin(),vec->end(),what)!=vec->end())
        return true;
    return false;
}






std