🤓 ✒️ 👨🏼‍🤝‍👨🏻 विंडोज एक्सप्लोरर के साथ सादृश्य द्वारा सूची को क्रमबद्ध करना 💕 🛄 👨‍👨‍👦

जब परियोजना लगभग पूरी हो जाती है और संपूर्ण व्यावसायिक तर्क परीक्षण में होता है, तो कभी-कभी "छोटी चीज़ों और चिप्स" और अन्य "सजावट" के साथ इसे पूरक करने की इच्छा होती है, उदाहरण के लिए, कुछ आइकनों को अधिक सुंदर लोगों को फिर से बनाएं, या एक अल्फा चैनल के साथ एक ढाल के माध्यम से तत्वों का चयन करें।
इस तरह के सहज इच्छा सूची के लिए बहुत सारे विकल्प हैं (विशेषकर यदि आपके पास समय है) और सभी अलंकरणों की एक श्रृंखला से जो अनिवार्य रूप से किसी भी शब्दार्थ भार को नहीं ले जाते हैं - लेकिन यह सब है।

इस मिनी-लेख में, मैं इनमें से एक "विशलिस्ट" पर विचार करूंगा।

मान लीजिए कि आपके पास TListView में प्रदर्शित तत्वों की एक सूची है, तो आप इसे क्रमबद्ध करने और ऐसा परिणाम प्राप्त करने का प्रयास करते हैं।

यह सुंदर नहीं है, यह "101" नाम के साथ दूसरा तत्व क्यों है? आखिरकार, यह एक संख्या है, और इसलिए इसे "2" नाम के साथ कम से कम तत्व के बाद एक जगह होना चाहिए। हां, और "नया फ़ोल्डर (101)" स्पष्ट रूप से "नया फ़ोल्डर (2)" के बाद होना चाहिए। सब के बाद, एक्सप्लोरर में सब कुछ सामान्य दिखता है।

आइए इस व्यवहार के कारणों को समझने की कोशिश करें और एक एल्गोरिथ्म को लागू करें जो अधिक सही है, एक मानव दृष्टिकोण से, छंटाई का।

पहले, चलो गलत छंटाई के कारणों को देखें।
डिफ़ॉल्ट रूप से, TListView तार की तुलना करने के लिए lstrcmp फ़ंक्शन का उपयोग करता है, जो वर्ण द्वारा तार वर्ण की तुलना करता है।

उदाहरण के लिए, यदि आप दो लाइनें "1" और "2" लेते हैं, तो पहली पंक्ति दूसरी से ऊपर स्थित होनी चाहिए, क्योंकि इकाई प्रतीक ड्यूस से पहले जाता है। हालांकि, अगर हम पहली पंक्ति के बजाय "101" लेते हैं, तो lstrcmp फ़ंक्शन यह भी कहेगा कि यह रेखा पहले जानी चाहिए, क्योंकि इस मामले में यह दोनों लाइनों के बहुत पहले चरित्र की तुलना करने के परिणाम पर निर्णय लेता है, इस तथ्य को ध्यान में नहीं रखते हुए कि दोनों लाइनें संख्याओं का एक स्ट्रिंग प्रतिनिधित्व हैं। ।

चलो इसे थोड़ा और अधिक जटिल बनाते हैं, "1a2" और "1a101" लाइनें लेते हैं, जिस पर lstrcmp फिर से गलत परिणाम देता है, यह कहते हुए कि दूसरी पंक्ति को पहले जाना चाहिए। वह इस निर्णय को दोनों तारों के तीसरे चरित्र की तुलना करने के परिणाम के आधार पर बनाती है, इस तथ्य के बावजूद कि इस मामले में वे संख्याओं के कड़े प्रतिनिधित्व भी हैं।

हमने कारणों का पता लगाया, अब हम एक समाधान के बारे में सोच रहे हैं।
चूंकि lstrcmp की तुलना में गलत है, प्रतीकों के रूप में संख्याओं के कुछ हिस्सों की व्याख्या करना, एक समान तुलना एल्गोरिथ्म को लागू करना आवश्यक है जिसमें संख्याओं की तुलना संख्याओं के रूप में की जाएगी, न कि प्रतीकों के रूप में।

एल्गोरिदमिक रूप से, यह काफी सरल है।

फिर से, "1a2" और "1a101" लें। हम उन्हें अलग-अलग घटकों में विभाजित करते हैं, जहां वर्ण संख्याओं से अलग हो जाएंगे। यदि हम "1 + ए + 2" के रूप में पहली पंक्ति का प्रतिनिधित्व करते हैं, और "1 + ए + 101" के रूप में दूसरा, यह पता चलता है कि हमें केवल तीन तुलनाओं को करने की आवश्यकता है।

1. संख्या के साथ संख्या
2. प्रतीक के साथ प्रतीक
3. फिर से संख्या के साथ संख्या

इस तरह की तुलना का परिणाम सही होगा और यह दिखाएगा कि दूसरी पंक्ति को वास्तव में दूसरी जगह जाना चाहिए, न कि पहली, क्योंकि lstrcmp ने हमें इस बारे में सूचित किया है।

अब हम इस एल्गोरिथ्म के कार्यान्वयन के लिए टीके पर विचार करेंगे।

यह स्पष्ट है कि:
1. यदि तुलना के लिए पारित लाइनों में से एक खाली है - यह पहले से ऊपर जाना चाहिए।
2. यदि दोनों रेखाएँ खाली हैं, तो वे समान हैं।
3. तुलना करते समय लाइनों के मामले को ध्यान में नहीं रखा जाता है।
4. लाइनों का विश्लेषण करने के लिए हम एक कर्सर का उपयोग करते हैं जिसमें प्रत्येक पंक्ति के वर्तमान पार्स चरित्र का पता होता है।
5. यदि किसी एक पंक्ति के कर्सर में एक संख्या होती है, और दूसरी पंक्ति के कर्सर में एक वर्ण होता है, तो पहली पंक्ति दूसरी से अधिक होती है।
6. यदि लाइन कर्सर एक चरित्र की ओर इशारा करते हैं - तुलना lstrcmp के समान है
7. यदि लाइन कर्सर एक संख्या की ओर इशारा करते हैं, तो हम दोनों संख्याओं को निकालते हैं और एक दूसरे के साथ तुलना करते हैं।
7.1 यदि दोनों संख्याएँ शून्य हैं (उदाहरण के लिए, "00" और "0000"), तो कम शून्य वाले नंबर को रखा जाता है।
8. यदि विश्लेषण के दौरान किसी भी लाइन के कर्सर को एक समाप्ति शून्य मिला - यह रेखा ऊपर जाती है।
.१ यदि उसी क्षण दूसरी पंक्ति का कर्सर भी समाप्ति शून्य पर है - रेखाएं समान हैं।

एल्गोरिथ्म को लागू करने के लिए, यह टीके पर्याप्त से अधिक है।
वास्तव में हम लागू करते हैं:

// // CompareStringOrdinal      , .. // "  (3)" < "  (103)" // //    // -1 -     // 0 -   // 1 -     // ============================================================================= function CompareStringOrdinal(const S1, S2: string): Integer; //  CharInSet    Delphi 2009, //        function CharInSet(AChar: Char; ASet: TSysCharSet): Boolean; begin Result := AChar in ASet; end; var S1IsInt, S2IsInt: Boolean; S1Cursor, S2Cursor: PChar; S1Int, S2Int, Counter, S1IntCount, S2IntCount: Integer; SingleByte: Byte; begin //     if S1 = '' then if S2 = '' then begin Result := 0; Exit; end else begin Result := -1; Exit; end; if S2 = '' then begin Result := 1; Exit; end; S1Cursor := @AnsiLowerCase(S1)[1]; S2Cursor := @AnsiLowerCase(S2)[1]; while True do begin //      if S1Cursor^ = #0 then if S2Cursor^ = #0 then begin Result := 0; Exit; end else begin Result := -1; Exit; end; //      if S2Cursor^ = #0 then begin Result := 1; Exit; end; //        S1IsInt := CharInSet(S1Cursor^, ['0'..'9']); S2IsInt := CharInSet(S2Cursor^, ['0'..'9']); if S1IsInt and not S2IsInt then begin Result := -1; Exit; end; if not S1IsInt and S2IsInt then begin Result := 1; Exit; end; //   if not (S1IsInt and S2IsInt) then begin if S1Cursor^ = S2Cursor^ then begin Inc(S1Cursor); Inc(S2Cursor); Continue; end; if S1Cursor^ < S2Cursor^ then begin Result := -1; Exit; end else begin Result := 1; Exit; end; end; //        S1Int := 0; Counter := 1; S1IntCount := 0; repeat Inc(S1IntCount); SingleByte := Byte(S1Cursor^) - Byte('0'); S1Int := S1Int * Counter + SingleByte; Inc(S1Cursor); Counter := 10; until not CharInSet(S1Cursor^, ['0'..'9']); S2Int := 0; Counter := 1; S2IntCount := 0; repeat SingleByte := Byte(S2Cursor^) - Byte('0'); Inc(S2IntCount); S2Int := S2Int * Counter + SingleByte; Inc(S2Cursor); Counter := 10; until not CharInSet(S2Cursor^, ['0'..'9']); if S1Int = S2Int then begin if S1Int = 0 then begin if S1IntCount < S2IntCount then begin Result := -1; Exit; end; if S1IntCount > S2IntCount then begin Result := 1; Exit; end; end; Continue; end; if S1Int < S2Int then begin Result := -1; Exit; end else begin Result := 1; Exit; end; end; end;

हम इस एल्गोरिदम के परिणाम को देखते हैं।

वास्तव में, जैसा कि अपेक्षित था।
अगला "डेकोरेटर" तैयार है।

आप निश्चित रूप से कह सकते हैं कि यह एक साइकिल है और आपको StrCmpLogicalW का उपयोग करने की आवश्यकता है:
msdn.microsoft.com/en-us/library/windows/desktop/bb759947

खैर, इसे आज़माएं - तीसरा बटन इस तरह की छंटाई के लिए जिम्मेदार है।
छँटाई के बाद सूची के पहले पाँच तत्वों पर ध्यान दें।

हालांकि वे कंडक्टर के प्रदर्शन के समान हैं, वे पूरी तरह से सच नहीं हैं। खैर, "0" नाम वाला तत्व तत्व "00" और अन्य के तहत स्थित नहीं होना चाहिए।

डेमो का स्रोत कोड इस लिंक से लिया जा सकता है।

विंडोज एक्सप्लोरर के साथ सादृश्य द्वारा सूची को क्रमबद्ध करना

More articles: