बबल सॉर्ट होमवर्क

Question

क्लास में हम एल्गोरिदम को सॉर्ट कर रहे हैं और, हालांकि मैं उनके बारे में बात करते समय उन्हें ठीक समझता हूं और स्यूडोकोड लिख रहा हूं, मुझे उनके लिए वास्तविक कोड लिखने में समस्या हो रही है।

यह पायथन में मेरा प्रयास है:

mylist = [12, 5, 13, 8, 9, 65]

def bubble(badList):
    length = len(badList) - 1
    unsorted = True

    while unsorted:
        for element in range(0,length):
            unsorted = False
            if badList[element] > badList[element + 1]:
                hold = badList[element + 1]
                badList[element + 1] = badList[element]
                badList[element] = hold
                print badList
            else:
                unsorted = True

print bubble(mylist)

अब, यह (जहाँ तक मैं बता सकता हूँ) सही ढंग से सॉर्ट करता है, लेकिन एक बार इसे पूरा करने के बाद यह अनिश्चित काल तक चलता रहता है।

इस कोड को कैसे ठीक किया जा सकता है ताकि फ़ंक्शन ठीक से और सही ढंग से किसी भी (उचित) आकार की सूची को सही ढंग से पूरा कर सके?

पीएस मुझे पता है कि मुझे वास्तव में एक समारोह में प्रिंट नहीं करना चाहिए और मुझे एक वापसी करनी चाहिए, लेकिन मैंने अभी तक ऐसा नहीं किया है क्योंकि मेरा कोड वास्तव में अभी तक काम नहीं करता है।

Comments

@ केएम - क्या उसे आपका लॉन मिलना चाहिए?

— आइडेन बेल

पोस्ट अनिवार्य रूप से है: "मुझे कोडिंग में परेशानी है, यही मैंने किया है, यह काम नहीं करता है।" स्पष्ट रूप से एक निहितार्थ है "क्या कोई मुझे कुछ संकेत दे सकता है कृपया?" कई होमवर्क प्रश्नों के विपरीत, यह एक (ए) अच्छी तरह से लिखा गया है, (बी) होमवर्क होने के बारे में उल्टा है, और (सी) में समस्या को हल करने का एक अच्छा प्रयास शामिल है। मुझे नहीं लगता कि एक वास्तविक प्रश्न चिह्न की कमी बहुत हद तक कम करती है ..

— जॉन फोहे

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

— छिपकली

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

— जेरेट हार्डी

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

— श्रीवत्सआर

Answer 1

यह समझाने के लिए कि आपकी स्क्रिप्ट अभी क्यों काम नहीं कर रही है, मैं चर unsortedका नाम बदल दूंगा sorted।

सबसे पहले, आपकी सूची अभी तक सॉर्ट नहीं की गई है। बेशक, हम सेट sortedकरते हैं False।

जैसे ही हम whileलूप शुरू करते हैं , हम मान लेते हैं कि सूची पहले से ही क्रमबद्ध है। विचार यह है: जैसे ही हमें दो तत्व मिलते हैं जो सही क्रम में नहीं होते हैं, हम sortedवापस सेट करते हैं False। केवल तभीsorted रहेगा True जब गलत क्रम में कोई तत्व नहीं थे ।

sorted = False  # We haven't started sorting yet

while not sorted:
    sorted = True  # Assume the list is now sorted
    for element in range(0, length):
        if badList[element] > badList[element + 1]:
            sorted = False  # We found two elements in the wrong order
            hold = badList[element + 1]
            badList[element + 1] = badList[element]
            badList[element] = hold
    # We went through the whole list. At this point, if there were no elements
    # in the wrong order, sorted is still True. Otherwise, it's false, and the
    # while loop executes again.

कुछ छोटे मुद्दे भी हैं जो कोड को अधिक कुशल या पठनीय बनाने में मदद करेंगे।

• में forपाश, आप चर का उपयोग element। तकनीकी रूप से, elementएक तत्व नहीं है; यह एक सूची सूचकांक का प्रतिनिधित्व करने वाला एक नंबर है। इसके अलावा, यह काफी लंबा है। इन मामलों में, बस एक अस्थायी चर नाम का उपयोग करें, जैसे i"सूचकांक"।

  for i in range(0, length):

• rangeआदेश भी सिर्फ एक तर्क (नाम ले जा सकते हैं stop)। उस स्थिति में, आपको 0 से उस तर्क तक सभी पूर्णांकों की एक सूची मिलती है।

  for i in range(length):

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

  def bubble(bad_list):

• दो चर के मूल्यों को स्वैप करने के लिए, उन्हें एक टपल असाइनमेंट के रूप में लिखें। दाहिने हाथ की ओर एक ट्यूपल के रूप में मूल्यांकन किया जाता है (कहते हैं, (badList[i+1], badList[i])है (3, 5)) और फिर बाएं हाथ की तरफ दो चर को सौंपा जाता है ( (badList[i], badList[i+1]))।

  bad_list[i], bad_list[i+1] = bad_list[i+1], bad_list[i]

यह सब एक साथ रखो, और आपको यह मिलता है:

my_list = [12, 5, 13, 8, 9, 65]

def bubble(bad_list):
    length = len(bad_list) - 1
    sorted = False

    while not sorted:
        sorted = True
        for i in range(length):
            if bad_list[i] > bad_list[i+1]:
                sorted = False
                bad_list[i], bad_list[i+1] = bad_list[i+1], bad_list[i]

bubble(my_list)
print my_list

(मैंने आपके प्रिंट स्टेटमेंट को भी हटा दिया, वैसे।)

Comments

कोड के उस आखिरी बिट पर, बुलबुला कुछ भी वापस नहीं करता है, इसलिए अंतिम परिणाम यह है कि 'कोई नहीं' मुद्रित है। आप शायद सूची वापस करना चाहते हैं, या बबल (my_list) करना चाहते हैं और फिर my_list प्रिंट करें।

— तुंग गुयेन

+1 अच्छी तरह से संरचित, स्पष्ट सलाह। आपको देखने के लिए महान है कि आपने क्या किया और क्यों न केवल एक त्वरित समाधान लिखें।

— टॉम लेन्स

मैं एक सी # प्रोग्रामर हूं, इसलिए यह सिर्फ इसलिए हो सकता है क्योंकि मुझे पायथन नहीं मिलता है, लेकिन सामान्य बुलबुला सॉर्ट एल्गोरिथ्म प्राप्त करने के लिए लंबाई से 1 को घटाने के लिए आपको लूप में कुछ नहीं चाहिए?

— मार्टिन ब्राउन

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

— वेस्ले

Put it all together, and you get this:... ठीक है, आप इस एक को याद किया:The range command can also take just one argument (named stop).

— पीटर Peráč

Answer 2

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

def bubble(badList):
    length = len(badList)
    for i in range(0,length):
        swapped = False
        for element in range(0, length-i-1):
            if badList[element] > badList[element + 1]:
                hold = badList[element + 1]
                badList[element + 1] = badList[element]
                badList[element] = hold
                swapped = True
        if not swapped: break

    return badList

आपका संस्करण 1, सही किया गया:

def bubble(badList):
    length = len(badList) - 1
    unsorted = True
    while unsorted:
        unsorted = False
        for element in range(0,length):
            #unsorted = False
            if badList[element] > badList[element + 1]:
                 hold = badList[element + 1]
                 badList[element + 1] = badList[element]
                 badList[element] = hold
                 unsorted = True
                 #print badList
             #else:
                 #unsorted = True

     return badList

Answer 3

यह तब होता है जब आप नकारात्मक अर्थ के चर नाम का उपयोग करते हैं, तो आपको उनके मूल्यों को पलटना होगा। निम्नलिखित को समझना आसान होगा:

sorted = False
while not sorted:
    ...

दूसरी ओर, एल्गोरिथ्म का तर्क थोड़ा हटकर है। आपको यह जांचना होगा कि लूप के दौरान दो तत्वों की अदला-बदली हुई या नहीं। यहाँ मैं इसे कैसे लिखूंगा:

def bubble(values):
    length = len(values) - 1
    sorted = False
    while not sorted:
        sorted = True
        for element in range(0,length):
            if values[element] > values[element + 1]:
                 hold = values[element + 1]
                 values[element + 1] = values[element]
                 values[element] = hold
                 sorted = False
    return values

Comments

यह थोड़ा बहुत बुरा है "उत्तर" बटन नहीं है जो मैं इस उत्तर के लिए मार सकता हूं। मुझे लगता है कि यह सवाल और प्रतिक्रियाएं - और विशेष रूप से मतदान - अगली बार जोएल स्पोल्स्की के बारे में बात करने की आवश्यकता है कि स्टैकओवरफ़्लो पर सामाजिक बातचीत को उन्होंने कितनी अच्छी तरह से ट्यून किया है।

— डैनियल मार्टिन

@ डैनियल: आप वह कर सकते हैं जो अन्य लोग पर्याप्त प्रतिष्ठा (100) के साथ कर सकते हैं - गलत जवाब को कम कर सकते हैं। सच्चाई का एक कीटाणु है - ध्वज चर में निहित नकारात्मक स्थिति खराब है। यह पूरा जवाब नहीं है, हालांकि - @McWafflestix में यह सही है, मुझे लगता है।

— जोनाथन लेफ़लर

आप लोग सही हैं, मैंने समय से पहले इस पर जवाब दिया। उसके लिए माफ़ करना।

— मार्टिन कॉट

@ मार्टिन - और मुझे इस बात की ओर ध्यान देना चाहिए कि मैं उत्तर से अधिक आश्चर्यचकित / हैरान हूँ। प्रतिष्ठा प्रणाली आपको प्रोत्साहित करती है कि आप पहले उत्तर दें, तुरंत। टूटा हुआ हिस्सा है कि कैसे एक गलत जवाब दिया जाता है।

— डेनियल मार्टिन

मुझे संदेह है कि अधिकांश लोग वास्तव में पहली जगह में सवाल को समझने के बिना मतदान करते हैं (जिस तरह से मैंने प्रश्न का उत्तर दिया)। OTOH, प्रश्न पूछने वाले को बाद में 'सही' उत्तर चुनने का विशेषाधिकार है।

— मार्टिन कोटे

Answer 4

अनरसेस्ड चर का आपका उपयोग गलत है; अगर आप दो तत्वों की अदला-बदली कर लेते हैं, तो आपको एक चर बताना होगा; यदि आपने ऐसा किया है, तो आप अपने पाश से बाहर निकल सकते हैं, अन्यथा, आपको फिर से लूप करने की आवश्यकता है। जो कुछ भी आपको यहां मिला है, उसे ठीक करने के लिए, अगर आपके केस में "अनसोल्ड = गलत" डाल दिया जाए; अपने मामले को हटा दें; और अपने forलूप से पहले "अनसर्टेड = सच" रखें ।

Answer 5

def bubble_sort(l):
    for passes_left in range(len(l)-1, 0, -1):
        for index in range(passes_left):
            if l[index] < l[index + 1]:
               l[index], l[index + 1] = l[index + 1], l[index]
    return l

Comments

मुझे लगता है कि यह प्रश्न 'इस कोड को कैसे ठीक किया जा सकता है' की तर्ज पर अधिक था, न कि 'आपका बुलबुला किस प्रकार है?'

— जोश हंट

आप बिल्कुल सही हैं, लेकिन इसे सही तरीके से करना अधिक महत्वपूर्ण है

— mtasic85

यह सच है, शायद, mtasic ... लेकिन होमवर्क के रूप में टैग की गई कोई भी चीज़ फिर से लिखी जाने के बजाय सबसे शिक्षाप्रद रूप से ट्विक की जाती है (विशेषकर जब यह ओपी द्वारा होमवर्क के रूप में टैग की जाती है)।

— जेरेट हार्डी

यह पाठ्य पुस्तक सी बबल सॉर्ट है जिसका अधिकांश लोग अध्ययन करते हैं। मैंने वही लिखा।

— लक्ष्मण प्रसाद

अच्छी जानकारी जोड़ना मेरे विचार में सहायक है। इतना अच्छा जवाब .. सोचा शायद आप जल्द से जल्द तोड़ने के लिए झंडे का इस्तेमाल कर सकते हैं।

— बृजेश चौहान

Answer 6

# ए बहुत ही सरल फ़ंक्शन, 2 सरणी के समस्या स्थान को कम करके (स्पष्ट रूप से) अनुकूलित किया जा सकता है। लेकिन वही ओ (एन ^ 2) जटिलता।

def bubble(arr):
    l = len(arr)        
    for a in range(l):
        for b in range(l-1):
            if (arr[a] < arr[b]):
            arr[a], arr[b] = arr[b], arr[a]
    return arr 

Comments

यह इस तरह से थोड़ा कम बेलबूटेदार है कि आप पायथन में मूल्यों की अदला-बदली कर सकते हैं: arr[a], arr[b] = arr[b], arr[a]

— Makoto

Answer 7

आपको वहां कुछ त्रुटियां मिली हैं। पहली लंबाई में है, और दूसरा आपके अनसोल्ड के उपयोग में है (जैसा कि McWafflestix द्वारा कहा गया है)। यदि आप इसे प्रिंट करने जा रहे हैं तो आप शायद सूची वापस करना चाहते हैं:

mylist = [12, 5, 13, 8, 9, 65]

def bubble(badList):
    length = len(badList) - 2
    unsorted = True

    while unsorted:
        for element in range(0,length):
            unsorted = False

            if badList[element] > badList[element + 1]:
                hold = badList[element + 1]
                badList[element + 1] = badList[element]
                badList[element] = hold
                print badList
                unsorted = True

    return badList

print bubble(mylist)

eta: तुम ठीक कह रहे हैं, ऊपर नरक के रूप में छोटी गाड़ी है। कुछ और उदाहरणों के माध्यम से परीक्षण नहीं करने के लिए मेरा बुरा।

def bubble2(badList):
    swapped = True
    length = len(badList) - 2

    while swapped:
        swapped = False
        for i in range(0, length):
            if badList[i] > badList[i + 1]:

                # swap
                hold = badList[i + 1]
                badList[i + 1] = badList[i]
                badList[i] = hold

                swapped = True

    return badList

Comments

लूप के लिए "अनसर्ड = गलत" नहीं होना चाहिए?

— श्वेन्ते

इसकी कुछ और समस्याएं थीं;)

— ट्रेवर ओके

Answer 8

मैं एक ताजा ताजा शुरुआत करने वाला हूं, कल पाइथन के बारे में पढ़ना शुरू किया। आपके उदाहरण से प्रेरित होकर मैंने 80-संबंधों की शैली में शायद कुछ और बनाया है, लेकिन फिर भी यह थोड़े काम करता है

lista1 = [12, 5, 13, 8, 9, 65]

i=0
while i < len(lista1)-1:
    if lista1[i] > lista1[i+1]:
        x = lista1[i]
        lista1[i] = lista1[i+1]
        lista1[i+1] = x
        i=0
        continue
    else:
        i+=1

print(lista1)

Answer 9

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

मैंने कोड को सरल बनाया और यह अब सूची की परवाह किए बिना संख्याओं की किसी भी सूची के लिए काम करेगा और भले ही संख्या दोहरा रहे हों। यहाँ कोड है

mylist = [9, 8, 5, 4, 12, 1, 7, 5, 2]
print mylist

def bubble(badList):
    length = len(badList) - 1
    element = 0
    while element < length:
        if badList[element] > badList[element + 1]:
            hold = badList[element + 1]
            badList[element + 1] = badList[element]
            badList[element] = hold
            element = 0
            print badList
        else:
            element = element + 1

print bubble(mylist)

Answer 10

def bubble_sort(l):
    exchanged = True
    iteration = 0
    n = len(l)

    while(exchanged):
        iteration += 1
        exchanged = False

        # Move the largest element to the end of the list
        for i in range(n-1):
            if l[i] > l[i+1]:
                exchanged = True
                l[i], l[i+1] = l[i+1], l[i]
        n -= 1   # Largest element already towards the end

    print 'Iterations: %s' %(iteration)
    return l

Comments

बुलबुला बड़ा तत्व अंत तक सभी तरह। और अंतिम काउंटर, "एन" को घटाएं ताकि आपको इसे फिर से तुलना न करना पड़े। जब तक एक्सचेंज हैं तब तक लूप के साथ जारी रखें। सबसे खराब स्थिति: O (N ^ 2) सर्वश्रेष्ठ मामला: O (N)

— Zile Rehman

Answer 11

def bubbleSort(alist):
if len(alist) <= 1:
    return alist
for i in range(0,len(alist)):
   print "i is :%d",i
   for j in range(0,i):
      print "j is:%d",j
      print "alist[i] is :%d, alist[j] is :%d"%(alist[i],alist[j])
      if alist[i] > alist[j]:
         alist[i],alist[j] = alist[j],alist[i]
return alist

एलिस्ट = [54,26,93,17,77,31,44,55,20, -23, और -34,16,11,11,11]

बबलसॉर्ट (एलिस्ट) प्रिंट करें

Comments

कृपया अपने कोड नमूने को सही ढंग से इंडेंट करें: यह, निश्चित रूप से, पायथन में विशेष रूप से महत्वपूर्ण है। आप यह भी समझाना चाहेंगे कि आपका समाधान इस बात पर विचार करने के लायक क्यों है कि 100 मतों के साथ एक उत्तर भी है

— kdopen

Answer 12

def bubble_sort(a):
    t = 0
    sorted = False # sorted = False because we have not began to sort
    while not sorted:
    sorted = True # Assume sorted = True first, it will switch only there is any change
        for key in range(1,len(a)):
            if a[key-1] > a[key]:
                sorted = False
                t = a[key-1]; a[key-1] = a[key]; a[key] = t;
    print a

Answer 13

एक सरल उदाहरण:

a = len(alist)-1
while a > 0:
    for b in range(0,a):
        #compare with the adjacent element
        if alist[b]>=alist[b+1]:
            #swap both elements
            alist[b], alist[b+1] = alist[b+1], alist[b]
    a-=1

यह बस तत्वों को 0 से a (मूल रूप से, उस दौर के सभी अनसुलझे तत्व) में ले जाता है और इसकी तुलना अपने आसन्न तत्व से करता है, और अगर यह अपने आसन्न तत्व से अधिक है तो स्वैप बनाता है। राउंड के अंत में, अंतिम तत्व को सॉर्ट किया जाता है, और प्रक्रिया फिर से इसके बिना चलती है, जब तक कि सभी तत्वों को सॉर्ट नहीं किया गया है।

एक शर्त की कोई जरूरत नहीं sortहै कि यह सच है या नहीं।

ध्यान दें कि यह एल्गोरिदम केवल स्वैप करते समय संख्याओं की स्थिति को ध्यान में रखता है, इसलिए बार-बार होने वाली संख्या इसे प्रभावित नहीं करेगी।

पुनश्च। मुझे पता है कि यह प्रश्न पोस्ट किए जाने के बाद से बहुत लंबा है, लेकिन मैं सिर्फ इस विचार को साझा करना चाहता था।

Answer 14

arr = [5,4,3,1,6,8,10,9] # array not sorted

for i in range(len(arr)):
    for j in range(i, len(arr)):
        if(arr[i] > arr[j]):
            arr[i], arr[j] = arr[j], arr[i]

            print (arr)

Answer 15

def bubble_sort(li):
    l = len(li)
    tmp = None
    sorted_l = sorted(li)
    while (li != sorted_l):
        for ele in range(0,l-1):
            if li[ele] > li[ele+1]:
                tmp = li[ele+1]
                li[ele+1] = li [ele]
                li[ele] = tmp
    return li

Answer 16

def bubbleSort ( arr ):
    swapped = True 
    length = len ( arr )
    j = 0

    while swapped:
        swapped = False
        j += 1 
        for i in range ( length  - j ):
            if arr [ i ] > arr [ i + 1 ]:
                # swap
                tmp = arr [ i ]
                arr [ i ] = arr [ i + 1]
                arr [ i + 1 ] = tmp 

                swapped = True

if __name__ == '__main__':
    # test list
    a = [ 67, 45, 39, -1, -5, -44 ];

    print ( a )
    bubbleSort ( a )
    print ( a )

Answer 17

def bubblesort(array):
    for i in range(len(array)-1):
        for j in range(len(array)-1-i):
            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]
    return(array)

print(bubblesort([3,1,6,2,5,4]))

Comments

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

— अलेक्जेंडर

Answer 18

मैं अपने समाधान को जोड़ने पर विचार करता हूं क्योंकि यहां कभी समाधान होता है

1. अधिक समय
2. अधिक से अधिक अंतरिक्ष जटिलता
3. या बहुत अधिक संचालन कर रहा है

तब होना चाहिए

तो, यहाँ मेरा समाधान है:

---

def countInversions(arr):
    count = 0
    n = len(arr)
    for i in range(n):
        _count = count
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                count += 1
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
        if _count == count:
            break
    return count

Answer 19

यदि किसी को सूची बोध का उपयोग करते हुए कम कार्यान्वयन में रुचि है:

def bubble_sort(lst: list) -> None:
    [swap_items(lst, i, i+1) for left in range(len(lst)-1, 0, -1) for i in range(left) if lst[i] > lst[i+1]]


def swap_items(lst: list, pos1: int, pos2: int) -> None:
    lst[pos1], lst[pos2] = lst[pos2], lst[pos1]

Answer 20

यहाँ forलूप के बिना बुलबुला प्रकार की एक अलग विविधता है । असल में आप विचार कर रहे हैं lastIndexकी arrayऔर धीरे धीरे decrementingयह जब तक सरणी के यह पहली बार सूचकांक।

algorithmजब तक एक पूरे पास किसी भी बिना किया जाता है इस तरह सरणी के माध्यम से स्थानांतरित करने के लिए जारी रहेगा swapsहोने वाली।

बबल सॉर्ट मूल रूप से है Quadratic Time: O(n²)जब यह प्रदर्शन की बात आती है।

class BubbleSort: 
  def __init__(self, arr):
    self.arr = arr;

  def bubbleSort(self):
    count = 0;
    lastIndex = len(self.arr) - 1;
    
    while(count < lastIndex):
      if(self.arr[count] > self.arr[count + 1]):
        self.swap(count)  
      count = count + 1;

      if(count == lastIndex):
        count = 0;
        lastIndex = lastIndex - 1;   

  def swap(self, count):
    temp = self.arr[count];
    self.arr[count] = self.arr[count + 1];
    self.arr[count + 1] = temp;
    
arr = [9, 1, 5, 3, 8, 2]
p1 = BubbleSort(arr)

print(p1.bubbleSort())

Answer 21

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

def bubble(badList):
    length = len(badList) - 1
    n = 0
    while n < len(badList):
        for element in range(0,length):
            if badList[element] > badList[element + 1]:
                hold = badList[element + 1]
                badList[element + 1] = badList[element]
                badList[element] = hold
                n = 0
            else:
                n += 1
    return badList

if __name__ == '__main__':
    mylist = [90, 10, 2, 76, 17, 66, 57, 23, 57, 99]
    print bubble(mylist)

अगर कोई भी टिप्पणी में मेरे कोड को बेहतर बनाने के बारे में कोई संकेत दे सकता है, तो यह बहुत सराहा जाएगा।

Comments

आप अपनी सूची के उस भाग को छोड़ कर एक बुलबुला-प्रकार को गति दे सकते हैं जिसे आप जानते हैं कि पहले से ही क्रमबद्ध है (पिछले पुनरावृत्तियों के कारण)। देखें en.wikipedia.org/wiki/Bubble_sort#Alternative_implementations

— Blorgbeard बाहर है

फिर, आपको वास्तव में एक बूलियन का उपयोग करने की आवश्यकता है (इसे अछूता कहें)। इसे अपने पाश के बाहर घोषित करें; लूप तक अछूता = सत्य नहीं। अपने समय के भीतर, सच होने के लिए अछूता सेट करें; अगर आपके शरीर में, असत्य को असत्य पर सेट करें। ऐसा करने से, आप अपने मामले को खोद सकते हैं। इस तरह, यदि आप कभी दो तत्वों को स्विच करते हैं, तो आपका लूप जारी रहेगा; यदि आप नहीं करते हैं, तो लूप नहीं होगा।

— पॉल सोनियर

Answer 22

इसे इस्तेमाल करे

a = int(input("Enter Limit"))


val = []

for z in range(0,a):
    b = int(input("Enter Number in List"))
    val.append(b)


for y in range(0,len(val)):
   for x in range(0,len(val)-1):
       if val[x]>val[x+1]:
           t = val[x]
           val[x] = val[x+1]
           val[x+1] = t

print(val)

Answer 23

idk अगर यह 9 साल के बाद आपकी मदद कर सकता है ... इसका एक साधारण बुलबुला सॉर्ट प्रोग्राम है

    l=[1,6,3,7,5,9,8,2,4,10]

    for i in range(1,len(l)):
        for j in range (i+1,len(l)):
            if l[i]>l[j]:
                l[i],l[j]=l[j],l[i]

Answer 24

def merge_bubble(arr):
    k = len(arr)
    while k>2:
        for i in range(0,k-1):
            for j in range(0,k-1):
                if arr[j] > arr[j+1]:
                    arr[j],arr[j+1] = arr[j+1],arr[j]

        return arr
        break
    else:
        if arr[0] > arr[1]:
            arr[0],arr[1] = arr[1],arr[0]
        return arr 

Answer 25

def bubble_sort(l):
    for i in range(len(l) -1):
        for j in range(len(l)-i-1):
            if l[j] > l[j+1]:
                l[j],l[j+1] = l[j+1], l[j]
    return l

Comments

अपने कोड में कुछ स्पष्टीकरण जोड़ना बेहतर होगा।

— मसूद रहिमी

Answer 26

def bubble_sorted(arr:list):
    while True:
        for i in range(0,len(arr)-1):
            count = 0
            if arr[i] > arr[i+1]:
                count += 1
                arr[i], arr[i+1] = arr[i+1], arr[i]
        if count == 0:
            break
    return arr
arr = [30,20,80,40,50,10,60,70,90]
print(bubble_sorted(arr))
#[20, 30, 40, 50, 10, 60, 70, 80, 90]

Answer 27

def bubbleSort(a): def swap(x, y): temp = a[x] a[x] = a[y] a[y] = temp #outer loop for j in range(len(a)): #slicing to the center, inner loop, python style for i in range(j, len(a) - j):
#find the min index and swap if a[i] < a[j]: swap(j, i) #find the max index and swap if a[i] > a[len(a) - j - 1]: swap(len(a) - j - 1, i) return a