निवेशन सॉर्ट बनाम चयन सॉर्ट

109

मैं प्रविष्टि सॉर्ट और चयन सॉर्ट के बीच के अंतरों को समझने की कोशिश कर रहा हूं।

उन्हें लगता है कि दो घटक हैं: एक अनसुलझी सूची और एक क्रमबद्ध सूची। वे दोनों एक सूची को अनसोल्ड सूची से लेते हैं और उचित स्थान पर छांटे गए सूची में डाल देते हैं। मैंने कुछ साइटों / पुस्तकों को यह कहते हुए देखा है कि चयन प्रकार एक समय में एक अदला-बदली करके करता है जबकि सम्मिलन प्रकार केवल सही स्थान पाता है और इसे सम्मिलित करता है। हालाँकि, मैंने अन्य लेखों को कुछ कहते हुए देखा है, यह कहते हुए कि प्रविष्टि प्रकार भी स्वैप करती है। नतीजतन, मैं उलझन में हूं। क्या कोई विहित स्रोत है?

— eb80
स्रोत

8

चयन प्रकार के लिए विकिपीडिया छद्म कोड और सुंदर चित्रों के साथ आता है, जैसा कि सम्मिलन प्रकार के लिए होता है ।

— जी बाख

6

@ G.Bach - इसके लिए धन्यवाद ... मैंने दोनों पृष्ठों को कई बार पढ़ा है लेकिन अंतर को नहीं समझता है - इसलिए यह प्रश्न है।

— Eb80

3

Computerphile के अनुसार वे समान हैं: youtube.com/watch?v=pcJHkWwjNl4

— ट्रिस्टन फॉरवर्ड

185

चयन छांटना:

एक सूची को देखते हुए, वर्तमान तत्व को लें और इसे वर्तमान तत्व के दाईं ओर सबसे छोटे तत्व के साथ विनिमय करें। चयन छांटना

सम्मिलन सॉर्ट:

किसी सूची को देखते हुए, वर्तमान तत्व को लें और सूची के उपयुक्त स्थान पर डालें, हर बार आपके द्वारा डाली गई सूची को समायोजित करते हुए। यह ताश के पत्तों के खेल में व्यवस्थित होने के समान है। सम्मिलन सॉर्ट

चयन प्रकार की समय जटिलता हमेशा होती है n(n - 1)/2, जबकि प्रविष्टि प्रकार में बेहतर समय जटिलता होती है क्योंकि इसकी सबसे खराब स्थिति होती है n(n - 1)/2। आम तौर पर यह कम या बराबर की तुलना में ले जाएगा n(n - 1)/2।

स्रोत: http://cheetahonfire.blogspot.com/2009/05/selection-sort-vs-insertion-sort.html

— निकोले कोस्तोव
स्रोत

2

@ नाइकोले - यह सिर्फ चीताहोनफायर.ब्लॉगस्पॉट.com/2009/05/… से कॉपी किया गया है जिसे मैंने पहले ही पढ़ा है। जैसा कि मैंने परस्पर विरोधी लेख पढ़े हैं, क्या कुछ और अधिक संक्षिप्त है।

— Eb80

5

मुख्य अंतर चयन चरण है। चयन प्रकार सबसे छोटे से एक का चयन करता है और इसे पहले एक के साथ स्वैप करता है। प्रविष्टि प्रकार वर्तमान को अपनी उपयुक्त स्थिति में सम्मिलित करता है

— निकोले कोस्तोव

6

@ eb80 मुझे यकीन नहीं है कि आप क्या सामग्री पढ़ रहे हैं, लेकिन मैं यह नहीं देखता कि कोई उदाहरण इससे अधिक ठोस कैसे हो सकता है?

— जी। बछ

23

लेकिन स्वैप की संख्या के बारे में क्या? चयन हमेशा n (n-1) / 2 तुलना करता है, लेकिन सबसे खराब स्थिति में यह केवल n-1 स्वैप करेगा। सबसे खराब स्थिति में सम्मिलन n (n-1) / 2 तुलना के साथ-साथ n (n-1) / 2 स्वैप करेगा।

— जेसन गोएमाट

2

@ इन दोनों में से कोई भी विभाजित नहीं है और एल्गोरिदम को जीतता है।

— एस्की मैकएफेसफेस नोव

63

सम्मिलन प्रकार और चयन प्रकार दोनों में एक बाहरी लूप (प्रत्येक सूचकांक पर), और एक आंतरिक लूप (सूचकांकों के सबसेट पर) होता है। आंतरिक लूप का प्रत्येक पास अनसोल्ड क्षेत्र की कीमत पर, एक तत्व द्वारा सॉर्ट किए गए क्षेत्र का विस्तार करता है, जब तक कि यह अनसोल्ड तत्वों से बाहर नहीं निकलता है।

अंतर यह है कि आंतरिक लूप क्या करता है:

चयन प्रकार में, आंतरिक लूप अनसोल्ड तत्वों पर है। प्रत्येक पास एक तत्व का चयन करता है, और इसे अपने अंतिम स्थान (सॉर्ट किए गए क्षेत्र के वर्तमान छोर पर) में ले जाता है।
सम्मिलन प्रकार में, आंतरिक लूप का प्रत्येक पास सॉर्ट किए गए तत्वों पर निर्भर करता है। सॉर्ट किए गए तत्वों को तब तक विस्थापित किया जाता है जब तक कि लूप को अगले अनसर्टेड एलिमेंट को डालने के लिए सही जगह न मिल जाए।

इसलिए, एक चयन प्रकार में, सॉर्ट किए गए तत्व आउटपुट ऑर्डर में पाए जाते हैं, और एक बार मिल जाने के बाद उन्हें रखा जाता है। इसके विपरीत, एक सम्मिलन प्रकार में, अनसर्टेड तत्व इनपुट क्रम में खपत होने तक रखे जाते हैं, जबकि सॉर्ट किए गए क्षेत्र के तत्व चारों ओर स्थानांतरित होते रहते हैं।

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

— comingstorm
स्रोत

23

चयन संधि
मान लें कि एक विशेष / यादृच्छिक फैशन में लिखी गई संख्याओं की संख्या है और हम कहते हैं कि हम बढ़ते क्रम में व्यवस्था कर रहे हैं..तो, एक समय में एक संख्या लें और उन्हें सबसे छोटी संख्या के साथ बदलें। सूची में उपलब्ध है। यह कदम उठाकर हम अंततः अपना वांछित परिणाम प्राप्त करेंगे।

INSERTION SORT
इसी तरह की धारणा को ध्यान में रखते हुए लेकिन केवल अंतर यह है कि इस बार हम एक समय में एक संख्या का चयन कर रहे हैं और इसे निर्धारित भाग में सम्मिलित कर रहे हैं, जिससे तुलना कम हो गई और इसलिए यह अधिक कुशल है।

— आकाश शर्मा
स्रोत

बस Youtube पर mycodeschool की जाँच करें । हालांकि, यह उत्तर तारीफ करता है कि यूट्यूब पर 2 एल्गोरिदम के वीडियो में क्या समझाया गया है।

— JaydeepW

21

ऐसा नहीं है कि भ्रम की स्थिति है, क्योंकि आप एक छँटाई का एक विवरण तुलना कर रहे हैं संभव है लिंक्ड सूची एक छँटाई के विवरण के साथ सरणी । लेकिन मुझे यकीन नहीं हो रहा है, क्योंकि आपने अपने स्रोतों का हवाला नहीं दिया है।

छँटाई एल्गोरिदम को समझने का सबसे आसान तरीका अक्सर एल्गोरिथ्म का विस्तृत विवरण प्राप्त करना है (न कि अस्पष्ट सामग्री जैसे "यह स्वैप का उपयोग करता है। कहीं नहीं। मैं यह नहीं कह रहा हूँ"), कुछ प्लेइंग कार्ड प्राप्त करें (5-10 पर्याप्त होना चाहिए। सरल प्रकार के एल्गोरिदम के लिए), और एल्गोरिथ्म को हाथ से चलाएं।

चयन प्रकार: सबसे छोटे शेष तत्व की तलाश कर रहे अनसोल्ड डेटा के माध्यम से स्कैन करें, फिर इसे सॉर्ट किए गए डेटा के तुरंत बाद स्थिति में स्वैप करें। समाप्त होने तक दोहराएं। यदि किसी सूची को क्रमबद्ध किया जाता है, तो आपको सबसे छोटे तत्व को स्थिति में स्वैप करने की आवश्यकता नहीं है, आप इसके बजाय सूची नोड को अपनी पुरानी स्थिति से हटा सकते हैं और इसे नए पर सम्मिलित कर सकते हैं।

सम्मिलन सॉर्ट: तत्व को सॉर्ट किए गए डेटा के तुरंत बाद ले लो, सॉर्ट किए गए डेटा के माध्यम से इसे लगाने के लिए जगह खोजने के लिए स्कैन करें और इसे वहां डाल दें। समाप्त होने तक दोहराएं।

सम्मिलन सॉर्ट अपने "स्कैन" चरण के दौरान स्वैप का उपयोग कर सकता है , लेकिन ऐसा नहीं है और यह सबसे कुशल तरीका नहीं है जब तक कि आप किसी डेटा प्रकार के एक सरणी को सॉर्ट नहीं कर रहे हैं: (ए) को स्थानांतरित नहीं किया जा सकता है, केवल कॉपी या स्वैप किया जा सकता है; और (b) स्वैप की तुलना में कॉपी करना अधिक महंगा है। यदि सम्मिलन प्रकार स्वैप का उपयोग करता है, तो जिस तरह से काम करता है वह यह है कि आप एक साथ जगह की खोज करते हैं और नए तत्व को वहां डालते हैं, नए तत्व को बार-बार उसके पहले तत्व के साथ बार-बार स्वैप करके, जब तक कि इससे पहले कि तत्व इससे बड़ा है यह। एक बार जब आप किसी ऐसे तत्व तक पहुँच जाते हैं जो बड़ा नहीं है, तो आपको सही स्थान मिल गया है और आप अगले नए तत्व पर चले जाते हैं।

— स्टीव जेसोप
स्रोत

1

यह बहुत मददगार है ... आखिरी पैराग्राफ उस भ्रम की ओर जाता है जो मैं कर रहा था, जो प्रत्येक प्रकार के वेरिएंट से उपजा था।

— Eb80

1

+1 यह ध्यान देने के लिए कि किसी लिंक की गई सूची पर सम्मिलन प्रकार का उपयोग करना एक इन-प्लेस सरणी की तुलना में पूरी तरह से अलग स्वैप दक्षता है

— गाविन अचैटेमेयर

11

दोनों एल्गोरिदम के लिए तर्क काफी समान है। इन दोनों के पास सरणी की शुरुआत में एक आंशिक रूप से उप-सरणी है। एकमात्र अंतर यह है कि वे किस तरह से अगले तत्व को छांटने के लिए खोजते हैं।

सम्मिलन प्रकार : अगले तत्व को सही स्थिति में सम्मिलित करता है;
चयन प्रकार : सबसे छोटे तत्व का चयन करता है और इसे वर्तमान आइटम के साथ विनिमय करता है;

चयन सॉर्ट के विपरीत , सम्मिलन सॉर्ट स्थिर है ।

मैंने अजगर में दोनों को लागू किया, और यह ध्यान देने योग्य है कि वे कितने समान हैं:

def insertion(data):
    data_size = len(data)
    current = 1
    while current < data_size:
        for i in range(current):
            if data[current] < data[i]:
                temp = data[i]
                data[i] = data[current]
                data[current] = temp

        current += 1

    return data

एक छोटे से बदलाव के साथ चयन सॉर्ट एल्गोरिथ्म बनाना संभव है।

def selection(data):
    data_size = len(data)
    current = 0
    while current < data_size:
        for i in range(current, data_size):
            if data[i] < data[current]:
                temp = data[i]
                data[i] = data[current]
                data[current] = temp

        current += 1

    return data

— थायगो का स्टाल
स्रोत

क्षमा करें, मैं सोच रहा था कि क्यों (चयन सॉर्ट एल्गोरिथ्म), डेटा [i] डेटा के साथ आदान-प्रदान किया जाता है [वर्तमान] जब भी डेटा [i] छोटा होता है। मूल / मूल (?) चयन प्रकार में, हम न्यूनतम मान सीमा के बीच पाते हैं (i, data_size) और विनिमय डेटा [i] उस न्यूनतम मूल्य के साथ ... यह थोड़ा अलग है ...

— टोनी मा

4

संक्षेप में, मुझे लगता है कि चयन प्रकार पहले सरणी में सबसे छोटे मूल्य के लिए खोज करता है, और फिर स्वैप करता है जबकि प्रविष्टि प्रकार एक मान लेता है और इसे छोड़ दिए गए प्रत्येक मूल्य (इसके पीछे) की तुलना करता है। यदि मान छोटा है, तो यह स्वैप हो जाता है। फिर, उसी मूल्य की फिर से तुलना की जाती है और यदि यह पीछे वाले से छोटा होता है, तो यह फिर से स्वैप हो जाता है। मुझे उम्मीद है कि इसका कोई अर्थ है!

— Muath
स्रोत

4

संक्षेप में,

चयन प्रकार: पहले वाले तत्व को अनसोल्ड एरे से चुनें और शेष अनसोल्ड एलिमेंट्स के साथ तुलना करें। यह बबल सॉर्ट के समान है, लेकिन प्रत्येक छोटे तत्वों को स्वैप करने के बजाय, सबसे छोटे तत्व इंडेक्स को अपडेट रखता है और प्रत्येक लूप के अंत में स्वैप करता है ।

सम्मिलन प्रकार: यह चयन सॉर्ट के विपरीत है जहां यह पहले से मौजूद तत्व को अनसोल्ड सब-ऐरे से चुनता है और सॉर्ट किए गए सब-ऐरे से इसकी तुलना करता है और जहां पाया गया है, वहां से सबसे छोटे तत्व को सम्मिलित करता है और इसके दाएं से पहले के सभी सॉर्ट किए गए तत्वों को शिफ्ट करता है।

— रवि
स्रोत

3

मैं इसे अभी तक एक और कोशिश दूँगा: विचार करें कि लगभग छांटे गए सरणी के भाग्यशाली मामले में क्या होता है।

सॉर्ट करते समय, सरणी को दो भागों के रूप में माना जा सकता है: बाएं हाथ की ओर - सॉर्ट किया गया, दाहिने हाथ की तरफ - अनसोल्ड।

सम्मिलन सॉर्ट - पहले अनसर्टेड एलिमेंट को चुनें और पहले से ही सॉर्ट किए गए हिस्से के बीच इसके लिए जगह खोजने की कोशिश करें। चूंकि आप दाएं से बाएं की ओर खोज करते हैं, इसलिए यह बहुत अच्छी तरह से हो सकता है कि आप जिस पहले सॉर्ट किए गए तत्व की तुलना कर रहे हैं (सबसे बड़ा, बाएं भाग में सबसे दाएं), वह चुना तत्व से छोटा है, इसलिए आप तुरंत अगले अनसोल्ड तत्व के साथ जारी रख सकते हैं।

चयन सॉर्ट - पहले अनस्रोल्ड एलिमेंट को चुनें और पूरे अनसोल्ड पार्ट के सबसे छोटे एलिमेंट को खोजने की कोशिश करें और अगर वांछित हो तो उन दोनों को एक्सचेंज करें। समस्या यह है कि, चूंकि दाहिना भाग अनसोल्ड है, इसलिए आपको हर बार हर तत्व के बारे में सोचना होगा, क्योंकि आप संभवतः यह सुनिश्चित नहीं कर सकते हैं कि उठाया गया कोई छोटा तत्व है या नहीं।

। Btw, इस वास्तव में क्या है heapsort चयन पर तरह बेहतर बनाता है - यह की वजह से अधिक तेजी से सबसे छोटा तत्व को खोजने के लिए सक्षम है ढेर ।

— एकिर हाना
स्रोत

3

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

सम्मिलन क्रमबद्ध: एल्गोरिथ्म फिर से सरणी को दो भाग में विभाजित करता है, लेकिन यहां तत्व को दूसरे भाग से उठाया गया है और पहले भाग के लिए सही स्थिति में डाला गया है। यह कभी भी गारंटी नहीं देता है कि पहले भाग को पूर्ण सरणी के संदर्भ में क्रमबद्ध किया गया है, हालांकि अंतिम पास में हर तत्व अपनी सही क्रमबद्ध स्थिति में है।

— mankadnandan
स्रोत

3

दोनों एल्गोरिदम आम तौर पर इस तरह से काम करते हैं

चरण 1: फिर अनसोल्ड लिस्ट से अगले अनसॉल्ट एलिमेंट को लें

चरण 2: इसे क्रमबद्ध सूची में सही जगह पर रखें।

एक एल्गोरिथ्म के लिए एक कदम आसान है और इसके विपरीत।

सम्मिलन सॉर्ट : हम अनसोल्ड सूची का पहला तत्व लेते हैं, इसे सॉर्ट की गई सूची में डालते हैं, कहीं । हमें पता है कि अगला तत्व (अनसोल्ड लिस्ट में पहला स्थान) कहां लेना है, लेकिन इसे कहां लगाना है इसके लिए कुछ काम करने की जरूरत है ( कहीं ) । चरण 1 आसान है।

चयन का प्रकार : हम तत्व को अनसोल्ड सूची से कहीं ले जाते हैं , फिर इसे क्रमबद्ध सूची के अंतिम स्थान पर रखते हैं। हमें अगला तत्व खोजने की आवश्यकता है (यह सबसे अधिक संभावना है कि यह अनसोल्ड लिस्ट की पहली स्थिति में नहीं है, बल्कि कहीं और है ) फिर इसे सॉर्ट की गई सूची के अंत में डाल दें। चरण 2 आसान है

— मेरा एक ग्रहणाधिकार
स्रोत

2

सम्मिलन सॉर्ट का आंतरिक लूप पहले से सॉर्ट किए गए तत्वों (चयन सॉर्ट के विपरीत) के माध्यम से जाता है। यह सही स्थिति मिलने पर आंतरिक लूप को खत्म करने की अनुमति देता है । जिसका अर्थ है कि:

आंतरिक लूप औसत मामले में अपने आधे तत्वों से गुजरेगा।
सरणी लगभग हल होने पर भी आंतरिक लूप को जल्द ही समाप्त कर दिया जाएगा।
आंतरिक लूप तुरंत समाप्त हो जाएगा यदि सरणी पहले से ही सॉर्ट की गई है, इस मामले में सम्मिलन प्रकार की जटिलता को जटिल बना देगा।

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

— दानिला पियातोव
स्रोत

1

मूल रूप से सम्मिलन प्रकार एक समय में दो तत्वों की तुलना करके काम करता है और चयन प्रकार पूरे सरणी से न्यूनतम तत्व का चयन करता है और इसे सॉर्ट करता है।

वैचारिक रूप से सम्मिलन सॉर्ट पूरी सूची के दो तत्वों की तुलना करके उप सूची को सॉर्ट करता रहता है, जबकि चयन सॉर्ट न्यूनतम तत्व का चयन करता है और इसे पहली स्थिति में दूसरे न्यूनतम तत्व को दूसरी स्थिति और इसी तरह स्वैप करता है।

प्रविष्टि प्रकार निम्नानुसार दिखाए जा सकते हैं:

    for(i=1;i<n;i++)
        for(j=i;j>0;j--)
            if(arr[j]<arr[j-1])
                temp=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=temp;

चयन प्रकार निम्नानुसार दिखाए जा सकते हैं:

    for(i=0;i<n;i++)
        min=i;
        for(j=i+1;j<n;j++)
        if(arr[j]<arr[min])
        min=j;
        temp=arr[i];
        arr[i]=arr[min];
        arr[min]=temp;

— Pankti
स्रोत

1

इन 2 सॉर्टिंग एल्गोरिदम का विकल्प उपयोग किए गए डेटा संरचना के लिए नीचे आता है।

जब आप सरणियों का उपयोग कर रहे हैं, तो चयन प्रकार का उपयोग करें (हालांकि क्यों, जब आप qsort का उपयोग कर सकते हैं?)। जब आप लिंक की गई सूचियों का उपयोग कर रहे हों, तो प्रविष्टि सॉर्ट का उपयोग करें।

यह है क्योंकि:

लिंक की गई सूची ट्रैवर्सल सरणियों से अधिक महंगी है।
लिंक्ड सूची प्रविष्टि सरणियों की तुलना में काफी सस्ती है।

सम्मिलन सॉर्ट नए मान को सॉर्ट किए गए सेगमेंट के बीच में इंजेक्ट करता है। इसलिए, डेटा को "पीछे धकेलने" की आवश्यकता है। हालाँकि, जब आप लिंक की गई सूची का उपयोग कर रहे हैं, तो 2 पॉइंटर्स घुमाकर, आपने पूरी सूची को प्रभावी रूप से पीछे धकेल दिया है। एक सरणी में, आपको n - प्रदर्शन करने के लिए वापस स्वैप करना होगा, जो बहुत महंगा हो सकता है।

चयन प्रकार हमेशा अंत तक होता है, इसलिए सरणियों का उपयोग करते समय यह समस्या नहीं होती है। इसलिए, डेटा को "पीछे धकेलने" की आवश्यकता नहीं है।

— जॉन
स्रोत

0

एक सरल व्याख्या नीचे दी जा सकती है:

दिया गया : एक अनसुलझा सरणी या संख्याओं की सूची।

समस्या का विवरण : चयन क्रम और सम्मिलन क्रमांक के बीच अंतर को समझने के लिए आरोही क्रम में सूची / संख्या को क्रमबद्ध करना।

सम्मिलन सॉर्ट:आप आसानी से समझने के लिए ऊपर से नीचे तक सूची देखें। हम पहले तत्व को अपना प्रारंभिक न्यूनतम मूल्य मानते हैं। अब, विचार यह है कि हम उस सूची / सरणी के प्रत्येक सूचकांक में रेखीय रूप से यह पता लगाने के लिए पार करते हैं कि क्या किसी भी सूचकांक में कोई अन्य तत्व है जो प्रारंभिक न्यूनतम मूल्य से कम मूल्य का है। अगर हमें ऐसा कोई मूल्य मिलता है, तो हम उनके इंडेक्स पर मानों की अदला-बदली करते हैं, अर्थात 15 को इंडेक्स 1 पर न्यूनतम प्रारंभिक मूल्य कहते हैं और इंडेक्स के रैखिक ट्रैवर्सल के दौरान, हम कम मूल्य के साथ एक नंबर पर आते हैं, कहते हैं कि इंडेक्स 9 पर 7 अब, सूचकांक 9 पर इस मान 7 को सूचकांक 1 के साथ स्वैप किया जाता है, जिसका मूल्य 15 है। यह ट्रावेल्स छोटे मूल्य के लिए स्वैप करने के लिए शेष इंडेक्स के साथ वर्तमान सूचकांक के मूल्य के साथ तुलना करना जारी रखेगा। यह सूची / सरणी के दूसरे अंतिम सूचकांक तक जारी रहता है,

चयन छांटना:मान लेते हैं कि सूची / सरणी का पहला सूचकांक तत्व हल है। अब दूसरे इंडेक्स पर मौजूद तत्व से, हम इसकी पिछली इंडेक्स से तुलना करके देखते हैं कि वैल्यू छोटा है या नहीं। ट्रैवर्सल को दो भागों में देखा जा सकता है, सॉर्ट और अनसोल्ड। एक सूची / सरणी में दिए गए सूचकांक के लिए सॉर्ट किए गए से अनसोल्ड से तुलना चेक की कल्पना होगी। मान लें कि आपके पास अनुक्रमणिका 1 पर मूल्य 19 और अनुक्रमणिका पर मान 10 है। हम अनसोल्ड से सॉर्ट किए गए को छांटते हैं, अर्थात दाएं से बाएं। तो, हम कहते हैं कि हमें सूचकांक 3 में क्रमबद्ध करना है। हम देखते हैं कि जब हम दाएं से बाएं की तुलना करते हैं तो इसका सूचकांक 1 से कम मूल्य होता है। एक बार पहचाने जाने के बाद, हम इंडेक्स 3 के इस नंबर 10 को इंडेक्स 1 के स्थान पर रखते हैं, जिसका मूल्य 19 है। इंडेक्स 1 पर मूल मूल्य 19 एक स्थान पर दाईं ओर स्थानांतरित हो जाता है।

मैंने कोई कोड नहीं जोड़ा है क्योंकि प्रश्न ट्रैवर्सल की विधि की अवधारणा को समझने के बारे में लगता है।

— सिड
स्रोत

0

सम्मिलन प्रकार चीजों को स्वैप नहीं करता है। भले ही यह एक अस्थायी चर का उपयोग करता है, लेकिन अस्थायी संस्करण का उपयोग करने की बात यह है कि जब हमने किसी सूचकांक में एक मान को उसके पिछले सूचकांक के मूल्य की तुलना में कम पाया, तो हम अधिक मूल्य को कम मूल्य के स्थान पर स्थानांतरित कर देते हैं सूचकांक जो चीजों को लिखना होगा। फिर हम पिछले इंडेक्स पर प्रतिस्थापित होने के लिए अस्थायी संस्करण का उपयोग करते हैं। उदाहरण: 10, 20, 30, 50, 40. पुनरावृत्ति 1: 10, 20, 30, 50, 50. [अस्थायी = 40] पुनरावृत्ति 2: 10,20, 30, 40 (अस्थायी मूल्य), 50. तो, हम बस कुछ चर से वांछित स्थान पर एक मूल्य डालें।

लेकिन जब हम चयन प्रकार पर विचार करते हैं, तो हम पहली बार सूचकांक को कम मूल्य पर पाते हैं और उस मूल्य को पहले सूचकांक से स्वैप करते हैं और तब तक बार-बार स्वैप करते रहते हैं जब तक कि सभी सूचकांकों को क्रमबद्ध नहीं किया जाता है। यह बिल्कुल दो नंबर की पारंपरिक स्वैपिंग के समान है। उदाहरण: ३०, २०, १०, ४०, ५०। १: १०, २०, ३०, ४०, ५०। यहाँ अस्थायी संस्करण का प्रयोग विशेष रूप से स्वैपिंग के लिए किया जाता है।

— अरविंदकुमार चिलकमरी
स्रोत

0

निवेशन सॉर्ट उस चयन को बहुत अधिक स्वैप करता है। यहाँ एक उदाहरण है:

— user4617883
स्रोत

0

दोनों में जो कुछ भी समान है वह यह है कि वे दोनों एक विभाजन का उपयोग सरणी के सॉर्ट किए गए भाग और अनसोल्ड के बीच अंतर करने के लिए करते हैं।

अंतर यह है, कि चयन प्रकार के साथ आपको यह गारंटी दी जाती है कि क्रमबद्ध भाग में तत्वों को जोड़ने पर सरणी का एक हिस्सा नहीं बदलेगा।

इसका कारण यह है, क्योंकि चयन बिना सेट के न्यूनतम के लिए खोज करता है और इसे सॉर्ट किए गए सेट के अंतिम तत्व के ठीक बाद जोड़ता है, जिससे क्रमबद्ध सेट 1 से बढ़ जाता है।

दूसरी ओर सम्मिलन, केवल अगले तत्व के बारे में परवाह करता है जो सामने है, जो कि सरणी के अनसोल्ड भाग में पहला तत्व है। यह इस तत्व को ले जाएगा और बस इसे सॉर्ट किए गए सेट में अपने उचित स्थान पर फिट कर देगा।

आम तौर पर प्रविष्टि सॉर्ट हमेशा उन एरियर्स के लिए एक बेहतर उम्मीदवार होगा जो केवल आंशिक रूप से हल किए जाते हैं क्योंकि आप न्यूनतम खोजने के लिए ऑपरेशन बर्बाद कर रहे हैं।

निष्कर्ष:

असंरचनात्मक रूप से चयन प्रकार असंगत अनुभाग में न्यूनतम तत्व को खोजकर एक तत्व को अंत में जोड़ता है।

सम्मिलन सॉर्ट पहले खंड में पाए गए पहले तत्व को सॉर्ट किए गए अनुभाग में कहीं भी प्रचारित करता है।

— मोशे राबाव
स्रोत

0

यद्यपि चयन प्रकार और सम्मिलन प्रकार की समय जटिलता समान है, जो n (n - 1) / 2 है। औसत प्रदर्शन प्रविष्टि सॉर्ट बेहतर है। यादृच्छिक 30000 पूर्णांक के साथ मेरे i5 सीपीयू पर परीक्षण किया गया, चयन प्रकार औसतन 1.5s लिया, जबकि प्रविष्टि प्रकार औसतन 0.6s लेते हैं।

— पसंद
स्रोत

StackOverflow में आपका स्वागत है और उत्तर के लिए धन्यवाद। सबसे अधिक संभावना है कि आप देख सकते हैं कि कई लोगों ने पहले ही दृश्य चित्र के साथ अच्छे उत्तर दिए हैं। उदाहरण के लिए निकोले कोस्तोव ने 7 साल पहले कहा था कि समय की जटिलता सम्मिलन के लिए सबसे खराब स्थिति में ही होती है। यदि आपको लगता है कि वह गलत है, तो हम आपके विवरण का विस्तार करने के लिए स्वागत करते हैं।

— मैक्सिम सगयादचनी

-1

आम शब्दों में, (और शायद समस्या की उच्च स्तरीय समझ प्राप्त करने का सबसे आसान तरीका है)

बबल सॉर्ट एक पंक्ति में खड़े होने और ऊंचाई से खुद को छाँटने की कोशिश करने के समान है। जब तक आप सही जगह पर न हों तब तक आप अपने बगल वाले व्यक्ति के साथ स्विच करते रहें। यह बाएं (या कार्यान्वयन के आधार पर दाएं) से सभी तरह से होता है और आप तब तक स्विच करते रहते हैं जब तक कि हर कोई हल न हो जाए।

चयन प्रकार में, हालांकि, आप जो कर रहे हैं वह कार्ड के एक हाथ की व्यवस्था के समान है। आप कार्डों को देखते हैं, सबसे छोटे को लेते हैं, इसे बाईं ओर सभी जगह रखें, और इसी तरह।

— हर्ष जी।
स्रोत

3

वह चयन और सम्मिलन के प्रकार के बीच अंतर के बारे में पूछ रहा है

— जूडिंग

-1

एक विशेष वस्तु (सबसे कम) का चयन करना और इसे i (पुनरावृत्ति नहीं) तत्व के साथ स्वैप करना। (यानी, पहले, दूसरे, तीसरे .......) इसलिए, एक तरफ क्रमबद्ध सूची बनाना।

सम्मिलन- पहले की तुलना दूसरे के साथ तीसरे की तुलना दूसरे और पहले के साथ चौथे की तुलना तीसरे, दूसरे और पहले के साथ ......

एक लिंक जहाँ सभी छँटाई की तुलना की जाती है

— nikhil2000
स्रोत