std :: map insert หรือ std :: map find?

สมมติว่าเป็นแผนที่ที่คุณต้องการเก็บรักษารายการที่มีอยู่ 20% ของเวลารายการที่คุณกำลังแทรกเป็นข้อมูลใหม่ มีข้อได้เปรียบในการทำ std :: map :: find แล้ว std :: map :: insert โดยใช้ iterator ที่ส่งคืนหรือไม่? หรือมันเร็วกว่าที่จะพยายามแทรกแล้วดำเนินการโดยขึ้นอยู่กับว่าตัววนซ้ำระบุว่าบันทึกนั้นหรือไม่ได้ใส่หรือไม่?

คำตอบคือคุณไม่ทำเช่นกัน แต่คุณต้องการทำสิ่งที่แนะนำโดยข้อ 24 ของEffective STLโดยScott Meyers :

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.first->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.first->second = v;
  }
}

ในการเรียก 'แทรก' เราจะจ่ายค่าโทรแพงเพื่อสร้างประเภทมูลค่าของเรา - และจากสิ่งที่คุณพูดในคำถามคุณจะไม่ใช้ค่าใหม่นี้ 20% ของเวลา ในกรณีข้างต้นหากการเปลี่ยนประเภทค่าแผนที่ไม่ใช่ตัวเลือกการ 'ค้นหา' จะมีประสิทธิภาพมากกว่าก่อนเพื่อตรวจสอบว่าเราจำเป็นต้องสร้างองค์ประกอบหรือไม่

อีกวิธีหนึ่งคือสามารถเปลี่ยนประเภทค่าของแผนที่เพื่อจัดเก็บที่จับไปยังข้อมูลโดยใช้ประเภทตัวชี้อัจฉริยะที่คุณชื่นชอบ การเรียกเพื่อแทรกใช้ตัวชี้ค่าว่าง (ถูกมากในการสร้าง) และเฉพาะในกรณีที่จำเป็นเท่านั้นที่จะสร้างชนิดข้อมูลใหม่

แทบจะไม่มีความแตกต่างของความเร็วระหว่าง 2 ตัวค้นหาจะส่งคืนตัววนซ้ำแทรกทำแบบเดียวกันและจะค้นหาแผนที่ต่อไปเพื่อดูว่ามีรายการอยู่แล้วหรือไม่

ดังนั้น .. มันขึ้นอยู่กับความชอบส่วนบุคคล ฉันพยายามแทรกและอัปเดตเสมอหากจำเป็น แต่บางคนไม่ชอบจัดการคู่ที่ส่งคืน

ฉันคิดว่าถ้าคุณค้นหาแล้วแทรกค่าใช้จ่ายเพิ่มเติมจะเป็นเมื่อคุณไม่พบคีย์และทำการแทรกหลังจากนั้น มันเหมือนกับการดูหนังสือตามลำดับตัวอักษรและไม่พบหนังสือเล่มนั้นจากนั้นจึงดูหนังสืออีกครั้งเพื่อดูว่าจะแทรกที่ไหน มันทำให้คุณเข้าใจว่าคุณจะจัดการกับกุญแจอย่างไรและหากมีการเปลี่ยนแปลงอยู่ตลอดเวลา ตอนนี้มีความยืดหยุ่นบางอย่างที่หากคุณไม่พบคุณสามารถเข้าสู่ระบบยกเว้นทำอะไรก็ได้ที่คุณต้องการ ...

หากคุณมีความกังวลเกี่ยวกับประสิทธิภาพคุณอาจต้องการที่จะตรวจสอบhash_map <>

โดยทั่วไปแผนที่ <> จะถูกนำไปใช้เป็นต้นไม้ไบนารี ขึ้นอยู่กับความต้องการของคุณ hash_map อาจมีประสิทธิภาพมากกว่า

ฉันดูเหมือนจะไม่มีคะแนนมากพอที่จะแสดงความคิดเห็น แต่ดูเหมือนว่าคำตอบที่ทำเครื่องหมายไว้จะยืดยาวสำหรับฉัน - เมื่อคุณพิจารณาว่าส่วนแทรกนั้นจะส่งคืนตัววนซ้ำไปทำไมต้องค้นหา lower_bound ในเมื่อคุณสามารถใช้ตัววนซ้ำที่ส่งคืนได้ แปลก.

คำตอบใด ๆ เกี่ยวกับประสิทธิภาพจะขึ้นอยู่กับการใช้งาน STL ของคุณ วิธีเดียวที่จะรู้ได้อย่างแน่นอนคือการเปรียบเทียบทั้งสองวิธี ฉันเดาว่าความแตกต่างไม่น่าจะมีนัยสำคัญดังนั้นให้ตัดสินใจตามสไตล์ที่คุณต้องการ

แผนที่ [คีย์] - ให้ stl จัดเรียงออก นั่นเป็นการสื่อสารความตั้งใจของคุณอย่างมีประสิทธิภาพมากที่สุด

ใช่ยุติธรรมพอ

หากคุณทำการค้นหาแล้วแทรกคุณกำลังแสดง 2 x O (บันทึก N) เมื่อคุณพลาดเนื่องจากการค้นหาจะแจ้งให้คุณทราบหากคุณต้องการแทรกไม่ใช่ตำแหน่งที่ควรจะแทรก (lower_bound อาจช่วยคุณได้) . เพียงแค่แทรกตรงแล้วตรวจสอบผลลัพธ์ก็เป็นวิธีที่ฉันจะไป