अमान्य <ऑपरेटर assertion

Question

मैं एक सरणी "_vec" में मानों के आधार पर सूचकांक सॉर्ट करने के लिए एक सरल तुलनित्र को लागू करने का प्रयास कर रहा हूं। मुझे एक "अवैध < ऑपरेटर" रन-टाइम त्रुटि संदेश मिल रहा है।

class Compare{ 
vector<int>& _vec; 
public: 
    Compare(vector<int>& vec) : _vec(vec) {} 
    bool operator()(size_t i, size_t j){ 
     if(_vec[i] != _vec[j]) 
     return _vec[i] < _vec[j]; 
     else 
     return (double)rand()/RAND_MAX < 0.5; 
    } 
}; 

मैं उपयोग कर रहा हूँ निम्नलिखित समारोह कॉल:

sort(inds.begin(),inds.end(),Compare(vals)); 

जहां inds 1 से 15 से सूचकांक युक्त सिर्फ एक सरणी है (माना) और मैं समझने के लिए निम्नलिखित कोड के साथ गलत है असफल vals लंबाई 15 की सरणी है जो कुछ मानों के साथ है जिनके क्रमबद्ध इंडेक्स मैं गणना करना चाहता हूं। कुल लक्ष्य सॉर्ट ऑर्डर को यादृच्छिक बनाना है जब vals में दो (या अधिक) प्रविष्टियां बराबर होती हैं। कोई मदद?

Answer 1

std::sort() तुलना ऑपरेशन स्थिर होने की अपेक्षा करता है - यदि दो आइटम की तुलना में कोई विशेष परिणाम लौटाया जाता है, तो तुलनात्मक रूप से उसी परिणाम को वापस कर देना चाहिए यदि उन वस्तुओं की बाद में तुलना की जाती है। जब आप एक यादृच्छिक मूल्य वापस करते हैं, तो जाहिर है कि यह जरूरी नहीं है।

सी ++ 03 25.3/4 "क्रमबद्ध और संबंधित संचालन" कहते हैं:

अगर हम समतुल्य परिभाषित (ए, बी) कंप्यूटर अनुप्रयोग (ए, बी) & & कंप्यूटर अनुप्रयोग (ख, एक के रूप में!), तो आवश्यकताओं कि कंप्यूटर अनुप्रयोग हैं और समतुल्य दोनों सकर्मक संबंधों हो:

• कंप्यूटर अनुप्रयोग (ए, बी) & & कंप्यूटर अनुप्रयोग (ख, ग) कंप्यूटर अनुप्रयोग का तात्पर्य (क, ग)
• समतुल्य (क, बी) & & समतुल्य (ख, ग) के समतुल्य का तात्पर्य (क, ग)

[नोट: ऐसी स्थिति में, यह दिखाया जा सकता है कि

• समतुल्य एक तुल्यता संबंध
• कंप्यूटर अनुप्रयोग एक अच्छी तरह से प्रेरित करता है - equiv
• द्वारा निर्धारित समानता वर्गों पर निर्धारित संबंध प्रेरित संबंध एक सख्त कुल क्रम है।

अंत टिप्पणी]

और स्पष्टीकरण के लिए, टेबल 28 एक तुल्यता संबंध परिभाषित करता है:

== एक तुल्यता संबंध, वह यह है कि है, यह निम्नलिखित गुण को संतुष्ट करता है:

• सभी के लिए, एक == ए।
• यदि एक == बी, तो बी == ए।

तो अपने Compare() आपरेशन एक तुल्यता संबंध का उत्पादन नहीं होगा।

डेटा को यादृच्छिक रूप से खोने के बजाय एक दावा प्राप्त करना अच्छा लगता है।

_vec में दो (या अधिक) प्रविष्टियों के बराबर हैं, तो क्रमबद्ध क्रम को यादृच्छिक करने की समस्या को हल करने का एक तरीका है उन इंडेक्स के लिए यादृच्छिक मान बनाना और इंडेक्स => के मानचित्र में उन यादृच्छिक मानों का ट्रैक रखना यादृच्छिक मूल्य या कुछ। बस सुनिश्चित करें कि आप उन यादृच्छिक मानों का ट्रैक और उपयोग इस तरह से करते हैं कि Compare() के संक्रमणीय और समकक्ष गुणों को पकड़ें।

Answer 2

std::sort उम्मीद अपने से कम ऑपरेटर एक सकर्मक संबंध आपूर्ति करने के लिए है, यानी जब तरह देखता है A < B सच है और B < C सच है, यह तात्पर्य कि A < C रूप में अच्छी तरह से सच है।

आपके कार्यान्वयन में, पारगमनशीलता नियम नहीं है: जब दो आइटम बराबर होते हैं, तो आप यादृच्छिक रूप से इस तरह बताते हैं कि उनमें से एक दूसरे से बड़ा है। यह डीबग दावे को ट्रिगर करता है।

इसे ठीक करने के लिए समान मानों के लिए झूठी वापसी करें।