क्या मूल्य से कतार तत्व को निकालना संभव है?

Question

मैं विशिष्ट मूल्य के साथ कतार से तत्व को हटाना चाहता हूं। ऐसी चीज कैसे करें? (मैं नक्शा और कतार के एक समवर्ती मिश्रण बनाने के लिए कोशिश कर रहा हूँ और वर्तमान में मैं this answer पर लागू करने के लिए कोशिश)

तो मैं वर्तमान में इस तरह के कोड है:

#ifndef CONCURRENT_QUEUED_MAP_H 
#define CONCURRENT_QUEUED_MAP_H 

#include <map> 
#include <deque> 
#include <boost/thread.hpp> 
#include <boost/thread/locks.hpp> 

template <class map_t_1, class map_t_2> 
class concurrent_queued_map 
{ 
private: 
    std::map<map_t_1, map_t_2> _ds; 
    std::deque<map_t_1> _queue; 
    mutable boost::mutex mut_; 
public: 
    concurrent_queued_map() {} 

    map_t_2 get(map_t_1 key) { 
     boost::mutex::scoped_lock lock(mut_); 
     return _ds[key]; 
    } 

    map_t_1 put(map_t_1 key, map_t_2 value) { 
     boost::mutex::scoped_lock lock(mut_); 
     _ds.insert(std::pair<map_t_1, map_t_2>(key,value)); 
     _queue.push_back(key); 
     return key; 
    } 

    map_t_2 get_last(map_t_1 key) { 
     boost::mutex::scoped_lock lock(mut_); 
     const map_t_1 k = _queue.front(); 
     return _ds[k]; 
    } 

    void remove_last(map_t_1 key) { 
     boost::mutex::scoped_lock lock(mut_); 
     const map_t_1 k = _queue.front(); 
     _ds.erase(k); 
     _queue.pop_front(); 
    } 

    void remove(map_t_1 key) { 
     boost::mutex::scoped_lock lock(mut_); 
     _queue.erase(std::remove(_queue.begin(), _queue.end(), key), _queue.end()); 
     _ds.erase(k); 
    } 

    int size() { 
     boost::mutex::scoped_lock lock(mut_); 
     return _ds.size(); 
    } 

}; 

#endif // CONCURRENT_QUEUED_MAP_H 

तो मैं क्या करूँ? मूल्य से कतार से कैसे निकालें? या भालू कोई एसटीएल या बूस्ट घटक है जो समान कतार है? इसका अर्थ यह होगा कि .front(), pop_front(); और push_back(key); और मूल्य के आधार पर खोज और मिटाएंगे?

Answer 1

एक Deque एक दृश्य कंटेनर है, तो आप केवल मूल्य, जो निकालें/मिटा मुहावरा के साथ सबसे अच्छा किया है द्वारा तत्वों को दूर कर सकते हैं:

std::deque<T> q; 
T val; 

q.erase(std::remove(q.begin(), q.end(), val), q.end()); 

आप std::queue अनुकूलक का उपयोग कर रहे हैं, तो आप यह बिल्कुल नहीं कर सकता है, क्योंकि एडाप्टर केवल front/back इंटरफ़ेस का खुलासा करता है और यह पुनरावृत्ति या लुकअप अर्थशास्त्र के लिए नहीं है।

यदि आप अपनी कतार को std::list के रूप में लागू करना चुनते हैं, तो इसके बजाय सदस्य फ़ंक्शन remove() का उपयोग करें।

Answer 2

इसे इस तरह से इंगित करें - दोनों कतार और मानचित्र दोनों का उपयोग करने के फायदे निकाल रहे हैं, और दोनों (कम से कम प्रदर्शन के मामले में) के नुकसान को रोकते हैं। मैप और डेक दोनों का प्रतिनिधित्व करने के लिए मैं बस deque<std::pair<map_t_1, map_t_2> > का उपयोग करूंगा। फिर मानचित्र लुकअप या संपादन को पूरे डेक के माध्यम से देखने की आवश्यकता होती है, इसलिए यह बहुत ही कुशल नहीं है।

अधिक कुशल समाधान प्राप्त करना अधिक कठिन होगा, क्योंकि आप कुंजी (मानचित्र) और इंडेक्स (प्रकृति ओडी डेक ऑर्डर करके आवश्यक) द्वारा दो अलग-अलग अनुक्रमण योजनाओं का सामना करने की कोशिश कर रहे हैं। इसे कुशलतापूर्वक करने के लिए मैं स्वयं-कार्यान्वित डबल-लिंक्ड-सूची (कतार के रूप में) को लिंक_लिस्ट प्रविष्टियों के लिए कुंजी के मानचित्र के साथ प्रस्तावित करता हूं। डबल लिंक्ड सूची प्रविष्टियों में मानचित्र में लुकअप के लिए कुंजी भी शामिल होगी जब कतार को तैयार/जोड़ना होगा।