std :: map insert або std :: map find?

Припустимо карту, де ви хочете зберегти існуючі записи. 20% випадків запис, який ви вставляєте, - це нові дані. Чи є перевага робити std :: map :: find, а потім std :: map :: insert, використовуючи цей повернутий ітератор? Або швидше зробити спробу вставки, а потім діяти, виходячи з того, вказує ітератор запис чи не був?

Відповідь - ви не робите ні того, ні іншого. Натомість ви хочете зробити щось, запропоноване пунктом 24 Ефективного STL від Скотта Майерса :

typedef map<int, int> MapType;    // Your map type may vary, just change the typedef

MapType mymap;
// Add elements to map here
int k = 4;   // assume we're searching for keys equal to 4
int v = 0;   // assume we want the value 0 associated with the key of 4

MapType::iterator lb = mymap.lower_bound(k);

if(lb != mymap.end() && !(mymap.key_comp()(k, lb->first)))
{
    // key already exists
    // update lb->second if you care to
}
else
{
    // the key does not exist in the map
    // add it to the map
    mymap.insert(lb, MapType::value_type(k, v));    // Use lb as a hint to insert,
                                                    // so it can avoid another lookup
}

Відповідь на це питання також залежить від того, наскільки дорого створювати тип значення, який ви зберігаєте на карті:

typedef std::map <int, int> MapOfInts;
typedef std::pair <MapOfInts::iterator, bool> IResult;

void foo (MapOfInts & m, int k, int v) {
  IResult ir = m.insert (std::make_pair (k, v));
  if (ir.second) {
    // insertion took place (ie. new entry)
  }
  else if ( replaceEntry ( ir.first->first ) ) {
    ir.second->second = v;
  }
}

Для типу значення, такого як int, вищезазначене буде більш ефективним, ніж пошук, за яким слід вставка (за відсутності оптимізації компілятора). Як зазначено вище, це тому, що пошук по карті відбувається лише один раз.

Однак для виклику для вставки потрібно, щоб у вас вже було побудовано нове "значення":

class LargeDataType { /* ... */ };
typedef std::map <int, LargeDataType> MapOfLargeDataType;
typedef std::pair <MapOfLargeDataType::iterator, bool> IResult;

void foo (MapOfLargeDataType & m, int k) {

  // This call is more expensive than a find through the map:
  LargeDataType const & v = VeryExpensiveCall ( /* ... */ );

  IResult ir = m.insert (std::make_pair (k, v));
  if (ir.second) {
    // insertion took place (ie. new entry)
  }
  else if ( replaceEntry ( ir.first->first ) ) {
    ir.second->second = v;
  }
}

Для того, щоб зателефонувати "вставити", ми платимо за дорогий дзвінок, щоб побудувати наш тип значення - і з того, що ви сказали у питанні, ви не будете використовувати це нове значення 20% часу. У наведеному вище випадку, якщо зміна типу значення карти не є можливістю, то ефективніше спочатку виконати "пошук", щоб перевірити, чи потрібно нам створювати елемент.

Крім того, тип значення карти можна змінити для збереження дескрипторів даних, використовуючи ваш улюблений тип розумного вказівника. Виклик для вставки використовує нульовий покажчик (дуже дешевий для побудови) і лише за необхідності створюється новий тип даних.

Між двома значеннями швидкості майже не буде різниці, find поверне ітератор, вставка зробить те саме і все одно здійснить пошук на карті, щоб визначити, чи вже існує запис.

Отже .. це залежить від особистих переваг. Я завжди намагаюся вставити, а потім оновити, якщо це необхідно, але деяким людям не подобається обробляти пару, яка повертається.

Я думаю, якщо ви знайдете, то вставте, додаткові витрати будуть, коли ви не знайдете ключ і виконуєте вставку після. Це як би переглядати книги в алфавітному порядку і не знаходити книгу, а потім ще раз переглядати книги, щоб побачити, куди її вставити. Це зводиться до того, як ви будете поводитися з клавішами та чи вони постійно змінюються. Тепер є певна гнучкість у тому, що якщо ви її не знайдете, ви можете увійти, виняток, робити все, що завгодно ...

Я загубився на верхній відповіді.

Знайти повертає map.end (), якщо він нічого не знаходить, що означає, що тоді ви додаєте нові речі

iter = map.find();
if (iter == map.end()) {
  map.insert(..) or map[key] = value
} else {
  // do nothing. You said you did not want to effect existing stuff.
}

вдвічі повільніше, ніж

map.insert

для будь-якого елемента, якого ще немає на карті, оскільки йому доведеться здійснити пошук двічі. Одного разу, щоб перевірити, чи є він там, знову знайти місце, де можна покласти нову річ.

Якщо ви стурбовані ефективністю, ви можете перевірити hash_map <> .

Зазвичай map <> реалізується як двійкове дерево. Залежно від ваших потреб, hash_map може бути більш ефективним.

Здається, у мене недостатньо балів, щоб залишити коментар, але поставлена ​​галочка відповіді здається мені довгою - коли ви вважаєте, що вставка все одно повертає ітератор, навіщо йти шукати lower_bound, коли ви можете просто використовувати повернутий ітератор. Дивно.

Будь-які відповіді щодо ефективності залежатимуть від точної реалізації вашого STL. Єдиний спосіб точно знати - це порівняти його в обох напрямках. Я припускаю, що різниця навряд чи буде суттєвою, тому приймайте рішення, виходячи зі стилю, який ви віддаєте перевагу.

map [ключ] - нехай stl це розбере. Це найбільш ефективно передає ваш намір.

Так, справедливо.

Якщо ви робите знахідку, а потім вставку, ви виконуєте 2 x O (журнал N), коли отримуєте промах, оскільки знаходження лише повідомляє, чи потрібно вставляти не туди, куди повинна йти вставка (lower_bound може вам там допомогти) . Просто пряма вставка, а потім вивчення результату - це шлях, яким я піду.