std :: bản đồ chèn hoặc std :: bản đồ tìm thấy?

Giả sử một bản đồ mà bạn muốn lưu giữ các mục nhập hiện có. 20% thời gian, mục nhập bạn đang chèn là dữ liệu mới. Có lợi thế khi thực hiện std :: map :: find then std :: map :: insert bằng cách sử dụng trình lặp được trả về đó không? Hay nhanh hơn là thử chèn và sau đó hành động dựa trên việc trình vòng lặp cho biết bản ghi đã được chèn hay chưa?

Câu trả lời là bạn cũng không. Thay vào đó, bạn muốn làm điều gì đó theo Mục 24 của STL Hiệu quả do Scott Meyers đề xuất :

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
}

Câu trả lời cho câu hỏi này cũng phụ thuộc vào việc tạo ra loại giá trị mà bạn đang lưu trữ trong bản đồ tốn kém như thế nào:

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;
  }
}

Đối với một loại giá trị chẳng hạn như int, ở trên sẽ hiệu quả hơn một tìm kiếm theo sau bởi một chèn (trong trường hợp không có tối ưu hóa trình biên dịch). Như đã nói ở trên, điều này là do việc tìm kiếm thông qua bản đồ chỉ diễn ra một lần.

Tuy nhiên, lệnh gọi chèn yêu cầu bạn phải có "giá trị" mới được xây dựng:

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;
  }
}

Để gọi 'chèn', chúng tôi đang trả tiền cho cuộc gọi đắt tiền để xây dựng loại giá trị của chúng tôi - và từ những gì bạn đã nói trong câu hỏi, bạn sẽ không sử dụng giá trị mới này 20% thời gian. Trong trường hợp trên, nếu thay đổi kiểu giá trị bản đồ không phải là một tùy chọn thì sẽ hiệu quả hơn trước tiên thực hiện 'tìm kiếm' để kiểm tra xem chúng ta có cần xây dựng phần tử hay không.

Ngoài ra, loại giá trị của bản đồ có thể được thay đổi để lưu trữ các chốt cho dữ liệu bằng cách sử dụng loại con trỏ thông minh yêu thích của bạn. Lệnh gọi chèn sử dụng một con trỏ null (cấu tạo rất rẻ) và chỉ khi cần thiết thì kiểu dữ liệu mới được xây dựng.

Sẽ hầu như không có bất kỳ sự khác biệt nào về tốc độ giữa 2, find sẽ trả về một trình lặp, insert cũng tương tự và sẽ tìm kiếm trên bản đồ để xác định xem mục đã tồn tại hay chưa.

Vì vậy, nó phụ thuộc vào sở thích cá nhân. Tôi luôn thử chèn và sau đó cập nhật nếu cần thiết, nhưng một số người không thích xử lý cặp được trả về.

Tôi sẽ nghĩ nếu bạn thực hiện tìm kiếm rồi chèn, thì chi phí bổ sung sẽ là khi bạn không tìm thấy chìa khóa và thực hiện việc chèn sau đó. Nó giống như xem qua các cuốn sách theo thứ tự bảng chữ cái và không tìm thấy cuốn sách, sau đó xem lại các cuốn sách để xem nơi cần chèn nó. Nó tóm tắt về cách bạn sẽ xử lý các phím và nếu chúng liên tục thay đổi. Bây giờ có một số linh hoạt trong đó nếu bạn không tìm thấy nó, bạn có thể đăng nhập, ngoại lệ, làm bất cứ điều gì bạn muốn ...

Tôi bị mất câu trả lời hàng đầu.

Tìm trả về map.end () nếu nó không tìm thấy gì có nghĩa là nếu bạn đang thêm những thứ mới thì

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.
}

chậm gấp đôi

map.insert

cho bất kỳ phần tử nào chưa có trong bản đồ vì nó sẽ phải tìm kiếm hai lần. Một lần để xem nó có ở đó hay không, một lần nữa để tìm vị trí để đặt thứ mới.

Nếu bạn lo lắng về tính hiệu quả, bạn có thể muốn xem hash_map <> .

Thông thường, bản đồ <> được thực hiện dưới dạng cây nhị phân. Tùy thuộc vào nhu cầu của bạn, một hash_map có thể hiệu quả hơn.

Tôi dường như không có đủ điểm để để lại nhận xét, nhưng câu trả lời được đánh dấu có vẻ khá dài đối với tôi - khi bạn cân nhắc rằng chèn trả về trình lặp, tại sao phải tìm kiếm Lower_bound, khi bạn chỉ có thể sử dụng trình lặp được trả về. Thật kỳ lạ.

Bất kỳ câu trả lời nào về hiệu quả sẽ phụ thuộc vào việc thực hiện chính xác STL của bạn. Cách duy nhất để biết chắc chắn là chuẩn cả hai cách. Tôi đoán rằng sự khác biệt khó có thể là đáng kể, vì vậy hãy quyết định dựa trên phong cách bạn thích.

map [key] - hãy phân loại nó ra. Đó là truyền đạt ý định của bạn một cách hiệu quả nhất.

Vâng, đủ công bằng.

Nếu bạn thực hiện một tìm kiếm và sau đó một đoạn chèn, bạn đang thực hiện 2 x O (log N) khi bạn bỏ lỡ vì lần tìm chỉ cho bạn biết nếu bạn cần chèn không phải nơi mà đoạn chèn sẽ đến (low_bound có thể giúp bạn ở đó) . Chỉ cần chèn thẳng và sau đó kiểm tra kết quả là con đường tôi muốn.