प्रविष्टि सॉर्ट बनाम बबल सॉर्ट एल्गोरिदम

Question

मैं कुछ सॉर्टिंग एल्गोरिदम को समझने की कोशिश कर रहा हूं, लेकिन मैं बबल सॉर्ट और इंसर्शन सॉर्ट एल्गोरिथ्म में अंतर देखने के लिए संघर्ष कर रहा हूं।

मुझे पता है कि दोनों ओ (एन ² ) हैं, लेकिन मुझे ऐसा लगता है कि बबल सॉर्ट में प्रत्येक पास के लिए सरणी के अधिकतम मूल्य को शीर्ष पर ले जाता है, जबकि प्रविष्टि सॉर्ट केवल सबसे कम मूल्य को प्रत्येक पास के नीचे सिंक करता है। क्या वे एक ही काम नहीं कर रहे हैं लेकिन अलग-अलग दिशाओं में?

सम्मिलन प्रकार के लिए, तुलना / संभावित स्वैप की संख्या शून्य से शुरू होती है और हर बार (यानी 0, 1, 2, 3, 4, ..., n) बढ़ जाती है, लेकिन बुलबुले के लिए ऐसा ही व्यवहार होता है, लेकिन अंत में सॉर्टिंग (यानी n, n-1, n-2, ... 0) क्योंकि बबल सॉर्ट को अब अंतिम तत्वों के साथ तुलना करने की आवश्यकता नहीं है क्योंकि वे सॉर्ट किए जाते हैं।

हालांकि इस सब के लिए, यह आम सहमति है कि सम्मिलन क्रम सामान्य रूप से बेहतर है। क्या कोई मुझे बता सकता है क्यों?

संपादित करें: मैं मुख्य रूप से उन एल्गोरिदम में अंतरों में दिलचस्पी रखता हूं कि एल्गोरिदम कैसे काम करते हैं, उनकी दक्षता या स्पर्शोन्मुख जटिलता नहीं।

Comments

यह कहीं और अच्छी तरह से प्रलेखित है: देखें, उदाहरण के लिए, en.wikipedia.org/wiki/Sorting_algorithm । यहां नकल करने के लिए व्यर्थ और एक अच्छा जवाब प्रशस्त होगा।

— बतशेबा

@ बाथशेबा 75 लोग जिन्होंने उत्थान किया है और 88k जिन्होंने सवाल देखा है वे असहमत लगते हैं; )

— 10

@ पार्सर: हा! अब मुझे उत्तरों की समीक्षा करनी है। वर्तमान उच्चतम उत्क्रमित उत्तर उपयोगी है; दूसरों के बारे में निश्चित नहीं। यहाँ कुछ उत्तर बिंदुओं को उत्तर डाउनवोटिंग द्वारा खो दिया गया है। स्वीकृत उत्तर में "यही कारण है कि प्रविष्टि सॉर्ट बुलबुला प्रकार की तुलना में तेज़ है" आवश्यक रूप से सही नहीं है।

— बाथशीबा

@ बाथशेबा ओह नो

— पार्सेकर

Answer 1

Ith पुनरावृत्ति में बुलबुला प्रकार में आपके पास ni-1 आंतरिक पुनरावृत्तियों (n ^ 2) / 2 कुल है, लेकिन प्रविष्टि प्रकार में आपके पास i'th कदम पर अधिकतम i पुनरावृत्तियां हैं, लेकिन i / 2 औसतन, जैसा कि आप लूप लूप को रोक सकते हैं पहले, के बाद आपको वर्तमान तत्व के लिए सही स्थिति मिली। तो आपके पास (0 से n तक) / 2 जो (n ^ 2) / 4 कुल है;

यही कारण है कि प्रविष्टि सॉर्ट बुलबुला प्रकार की तुलना में तेज है।

Comments

मुझे लगता है कि हर जगह वेब पर एल्गोरिथम स्पष्टीकरण है।

— साशा.सोचका

हाँ, लेकिन ऐसा लगता है कि ओपी अभी भी तंत्र में अंतर नहीं पकड़ता है

— UmNyobe

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

— मिगवेल

क्या? "तो आपके पास (0 से n तक का योग) / 2 जो (n ^ 2) / 4 कुल है" जिसके लिए कुछ खोज की आवश्यकता है, कृपया! 0 + 1 + 2 + 3 + 4 + 5 = 15; 15/2 = 7.5; 7.5 * 4 = 30; sqrt (30) = जिबरिश

— जॉन स्मिथ

@ जॉनसन मुझे लगता है कि उत्तर में थोड़ी सी त्रुटि है। 1 से n तक का योग n * (n + 1) / 2 है क्योंकि यह एक त्रिकोणीय संख्या है। अधिक स्पष्टीकरण के लिए त्रिकोणीय संख्या देखें। ताकि 2 से विभाजित हो बस n * (n + 1) / 2 हो।

— कॉग्निजेंटअपे

Answer 2

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

I पुनरावृत्तियों के बाद पहले i तत्वों का आदेश दिया जाता है।

प्रत्येक पुनरावृत्ति में अगला तत्व तब तक छांटे गए खंड के माध्यम से बुदबुदाया जाता है जब तक कि वह सही स्थान पर न पहुँच जाए:

sorted  | unsorted
1 3 5 8 | 4 6 7 9 2
1 3 4 5 8 | 6 7 9 2

4 को सॉर्ट किए गए अनुभाग में बबल्ड किया गया है

स्यूडोकोड:

for i in 1 to n
    for j in i downto 2
        if array[j - 1] > array[j]
            swap(array[j - 1], array[j])
        else
            break

बबल शॅाट

I पुनरावृत्तियों के बाद अंतिम i तत्व सबसे बड़े और क्रमबद्ध हैं।

प्रत्येक पुनरावृत्ति में, अधिकतम खोजने के लिए अनसोल्ड सेक्शन के माध्यम से झारना ।

unsorted  | biggest
3 1 5 4 2 | 6 7 8 9
1 3 4 2 | 5 6 7 8 9

5 को अनसोल्ड सेक्शन से बुदबुदाया जाता है

स्यूडोकोड:

for i in 1 to n
    for j in 1 to n - i
         if array[j] > array[j + 1]
             swap(array[j], array[j + 1])

ध्यान दें कि यदि बाहरी स्वैप के पुनरावृत्तियों में से एक के दौरान कोई स्वैप नहीं किया गया है, तो ठेठ कार्यान्वयन जल्दी समाप्त हो जाता है (क्योंकि इसका अर्थ है कि सरणी को क्रमबद्ध किया गया है)।

अंतर

सम्मिलन में, सॉर्ट किए गए तत्वों को सॉर्ट किए गए सेक्शन में बुदबुदाया जाता है, जबकि बबल सॉर्ट में मैक्सिमम को अनसोल्ड सेक्शन से बुबल्ड किया जाता है।

Comments

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

— मिगवेल

मुझे लगता है कि यह सबसे अच्छा जवाब होना चाहिए :)

— एडेलिन

प्लस 1 स्पष्टता के लिए, सैद्धांतिक मूल्य और प्रत्येक एल्गोरिथ्म के मुख्य लूप चालकता के लिए। यह एक दया है, इसमें स्पष्ट रूप से जटिलता की तुलना नहीं है ( एन के एक समारोह के रूप में व्यक्त ), वैसे भी मैं इसे स्वीकार किए जाते हैं की तुलना में बेहतर उत्तर मानता हूं, क्योंकि इससे मैं अंतर देख सकता हूं ।

— होन्ज़ा ज़िदेक

क्या मैं यह पूछ सकता हूं कि आप हर कदम पर अपने सम्मिलन छद्म कोड में अपने आइटम को स्वैप क्यों कर रहे हैं? यदि ([[j-1]> [a] j तो = [j] = [j-१] ELSE यदि ([j-१] <e && a [j]> e) से [j] = ई; ब्रेक; , जहां ई को आइटम सॉर्ट करने की आवश्यकता है। इस समाधान के साथ, आप पहले से ही क्रमबद्ध वस्तुओं को स्वैप नहीं कर रहे हैं, बस उन्हें कॉपी कर रहे हैं। आप स्पष्टीकरण के लिए आगे देख रहे हैं, क्योंकि मैं थोड़ा भ्रमित हूँ।

— Karoly

@ केरोली, मैंने अपना संस्करण चुना क्योंकि यह सरल है। तुम्हारा थोड़ा तेज है, यह अच्छा है कि आप इसे इंगित करते हैं। विकिपीडिया दोनों संस्करण का वर्णन करता है।

— टॉम

Answer 3

एक और अंतर, मैंने यहाँ नहीं देखा:

बबल सॉर्ट में प्रति स्वैप 3 वैल्यू असाइनमेंट हैं : आपको उस वैल्यू को बचाने के लिए सबसे पहले एक अस्थायी वैरिएबल बनाना होगा, जिसे आप आगे बढ़ाना चाहते हैं (नंबर 1), इससे पहले कि आपने जो वैल्यू सेव की है, उसमें दूसरे स्वैप-वेरिएबल को लिखना होगा। of (no.2) और फिर आपको अपने अस्थायी चर को दूसरे स्थान (no.3) में लिखना होगा। आपको प्रत्येक स्पॉट के लिए ऐसा करना होगा - आप अपने वेरिएबल को सही स्पॉट पर सॉर्ट करने के लिए आगे बढ़ना चाहते हैं।

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

यह बहुत कम मूल्य का कार्य करता है, भी।

यह सबसे मजबूत गति-लाभ नहीं है, लेकिन मुझे लगता है कि इसका उल्लेख किया जा सकता है।

मुझे आशा है, मैंने खुद को समझने योग्य व्यक्त किया, यदि नहीं, तो क्षमा करें, मैं एक नटिव ब्रिटेन नहीं हूं

Comments

"और फिर उस स्थान के सामने सभी चर 1 स्थान पीछे रखें" - और क्या डेटा को शिफ्ट करने के लिए भी असाइनमेंट के भार की आवश्यकता नहीं है? (यह मानते हुए कि डेटा किसी भी तरह से नहीं, बल्कि लिंक्ड-लिस्ट में संचित है)

— मार्क के कोवान

@MarkKCowan, हाँ, यह वह जगह है जहाँ प्रविष्टि प्रकार 'स्पॉट' के अनुसार असाइनमेंट बनाता है जैसा कि उपर्युक्त उपयोगकर्ता ने रखा है। मूल रूप से, सम्मिलन प्रकार को आंतरिक लूप में एक असाइनमेंट के साथ लिखा जा सकता है, जबकि बुलबुले के आंतरिक लूप में 3 असाइनमेंट होते हैं।

— JSQuareD

Answer 4

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

मुझे लगता है, यह अन्य पारंपरिक n log(n)एल्गोरिदम की तुलना में तेज़ होगा । चूँकि जटिलता n*(n log(n))उदा। धारा से प्रत्येक मान को पढ़ना / संग्रहीत करना ( O(n)) और फिर सभी मानों को छाँटना ( O(n log(n))) जिसके परिणामस्वरूपO(n^2 log(n))

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

Comments

यदि यह डेटा के इन-ऑर्डर ट्रैवर्सल के लिए ठीक है, तो केवल एक सरणी को स्कैन करने के अलावा कुछ और हो सकता है, तो आप फ्लाई पर अधिक कुशलता से सॉर्ट कर सकते हैं। जैसे कि आप उन्हें प्राप्त एक द्विआधारी पेड़ में तत्वों को सम्मिलित करें। यह आपको O(n log(n))कुल मिलाकर हर कदम पर संग्रहित किए गए काम को देता है । (किसी भी बिंदु पर इन-ऑर्डर ट्रैवर्सल है O(m))। यदि आपको अंत में एक हल किए गए परिणाम की आवश्यकता है, लेकिन डेटा के हस्तांतरण के समय के साथ छँटाई गणना को ओवरलैप करना चाहते हैं तो ढेर अच्छा हो सकता है। (और इन-प्लेस की तरह काम करता है, जैसे सम्मिलन-प्रकार)।

— पीटर कॉर्डेस

वैसे भी, न तो बबल-सॉर्ट और न ही सम्मिलन-प्रकार इसके लिए आदर्श हैं, समस्या के आकार के साथ O(f(n))जटिलता वर्ग के लिए पर्याप्त है जो कार्यान्वयन विवरण और निरंतर कारकों से अधिक मायने रखता है।

— पीटर कॉर्डेस

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

— पीटर कॉर्डेस

वैसे भी, यदि आपको nसम्मिलन के लिए एक सॉर्ट किए गए सरणी को बनाए रखने की आवश्यकता है , तो वास्तव में यह उबलता है कि एल्गोरिथ्म लगभग-सॉर्ट किए गए सरणी को सॉर्ट करने के लिए सबसे अच्छा है जहां शीर्ष पर एक अन-सॉर्ट किया गया तत्व है। कई O(n log(n))सॉर्टिंग एल्गोरिदम O(n)लगभग-सॉर्ट किए गए मामले में हैं, इसलिए यह सच नहीं है कि आपको sum(M=1..n, O(M * log(M)) )काम की आवश्यकता होगी । यह वास्तव में होगा O(n^2 log(n)), लेकिन एल्गोरिथ्म के सही विकल्प के साथ वे O(n^2)कुल काम होंगे। सम्मिलन-प्रकार इसके लिए सबसे अधिक कुशल है, यद्यपि।

— पीटर कॉर्ड्स

Answer 5

बबल सॉर्ट ऑनलाइन नहीं है (यह न जाने कितने आइटम होंगे इसके बिना इनपुट की एक धारा को सॉर्ट कर सकते हैं) क्योंकि यह वास्तव में एक वैश्विक अधिकतम सॉर्ट किए गए तत्वों का ट्रैक नहीं रखता है। जब कोई आइटम डाला जाता है तो आपको शुरुआत से ही बुदबुदाहट शुरू करनी होगी

Answer 6

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

Answer 7

यद्यपि दोनों प्रकार O (N ^ 2) हैं। छिपे हुए स्थिरांक सम्मिलन के प्रकार में बहुत छोटे हैं। स्थिर स्थिरांक, बाहर किए गए आदिम संचालन की वास्तविक संख्या को संदर्भित करता है।

जब प्रविष्टि प्रकार बेहतर चल रहा है समय?

1. ऐरे लगभग सॉर्ट-नोटिस है कि प्रविष्टि सॉर्ट इस मामले में बबल सॉर्ट की तुलना में कम संचालन करता है।
2. सरणी अपेक्षाकृत छोटे आकार की है: सम्मिलन प्रकार आप तत्वों को चारों ओर ले जाते हैं, वर्तमान तत्व को रखने के लिए। यह केवल बुलबुला सॉर्ट से बेहतर है यदि तत्वों की संख्या कुछ है।

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

Comments

यदि तत्वों की संख्या छोटी नहीं है, तो बबल सॉर्ट बेहतर कैसे होगा? मेरी समझ यह है कि आप आईएस में स्लाइड करते हैं या बीएस में स्वैप इस बात पर निर्भर करते हैं कि तुलनात्मक तत्व अधिक है (आईएस) या छोटा (बीएस) और तत्वों के # पर नहीं। कृपया गलत होने पर मुझे सुधारें।

— मुस्तफा

Answer 8

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

Answer 9

प्रत्येक पुनरावृत्ति में स्वैप की संख्या

• सम्मिलन-प्रकार प्रत्येक पुनरावृत्ति में अधिकतम 1 स्वैप करता है ।
• बबल-सॉर्ट प्रत्येक पुनरावृत्ति में 0 से n स्वैप करता है।

छांटे गए भाग को एक्सेस करना और बदलना

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

ऑनलाइन या नहीं

• सम्मिलन-प्रकार ऑनलाइन है। इसका मतलब है कि सम्मिलन-प्रकार एक इनपुट को उचित स्थिति में रखने से पहले एक समय में लेता है । इसकी केवल तुलना नहीं करनी है adjacent-inputs।
• बबल-सॉर्ट ऑनलाइन नहीं है। यह एक बार में एक इनपुट को संचालित नहीं करता है। यह प्रत्येक पुनरावृत्ति में इनपुट (यदि सभी नहीं) का एक समूह संभालता है। बबल-सॉर्ट केवलadjacent-inputs प्रत्येक पुनरावृत्ति में तुलना और स्वैप करते हैं।

Answer 10

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

1. सम्मिलन की तरह स्वैपिंग की आवश्यकता नहीं है।

2. प्रविष्टि के प्रकार की समय जटिलता O (n) सर्वश्रेष्ठ मामले के लिए और O (n ^ 2) सबसे खराब स्थिति है।

बुलबुला प्रकार की तुलना में 3. जटिल जटिल।

4.example: लाइब्रेरी में किताबें डालें, कार्ड की व्यवस्था करें।

बुलबुला सॉर्ट: 1. सॉर्टिंग बुलबुला सॉर्ट में आवश्यक है।

2. सबसे अच्छा मामला और O (n ^ 2) सबसे खराब स्थिति के लिए बुलबुला सॉर्ट की समय जटिलता Ω (n) है।

प्रविष्टि प्रकार की तुलना में 3.more जटिल।

Comments

कैसे स्वैपिंग की आवश्यकता नहीं है? यह तत्वों को सही स्थिति में डालने के लिए स्वैप करता है। और मैं यह नहीं कहूंगा कि बबल सॉर्ट अधिक जटिल है।

— परसकर

Answer 11

सम्मिलन सॉर्ट को फिर से शुरू किया जा सकता है " तत्व की तलाश करें जो पहली स्थिति में होना चाहिए (न्यूनतम), अगले तत्वों को स्थानांतरित करके कुछ जगह बनाएं और इसे पहले स्थान पर रखें। अच्छा। अब उस तत्व को देखें जो 2 वें पर होना चाहिए। ... "और इसी तरह ...

बबल सॉर्ट अलग से संचालित होता है जिसे " जब तक मुझे दो आसन्न तत्व मिलते हैं जो कि गलत क्रम में हैं, मैं उन्हें स्वैप कर देता हूं "।

Comments

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

— मिगवेल

क्या वह चयन क्रमबद्ध नहीं है?

— हेरोल्ड

ओह, यह सच है ^

— मिगवेल