Bubble Sort Hausaufgaben

130

Im Unterricht machen wir Sortieralgorithmen und obwohl ich sie gut verstehe, wenn ich über sie spreche und Pseudocode schreibe, habe ich Probleme, tatsächlichen Code für sie zu schreiben.

Dies ist mein Versuch in Python:

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)

Nun, dies wird (soweit ich das beurteilen kann) richtig sortiert, aber sobald es fertig ist, wird es nur auf unbestimmte Zeit wiederholt.

Wie kann dieser Code behoben werden, damit die Funktion ordnungsgemäß beendet und eine Liste mit einer beliebigen (angemessenen) Größe sortiert wird?

PS Ich weiß, ich sollte eigentlich keine Ausdrucke in einer Funktion haben und ich sollte eine Rückgabe haben, aber ich habe das nur noch nicht getan, da mein Code noch nicht wirklich funktioniert.

Josh Hunt
quelle
29
@KM - Sollte er von Ihrem Rasen bekommen?
Aiden Bell
123
Der Beitrag lautet im Wesentlichen: "Ich habe Probleme beim Codieren, das habe ich getan, es funktioniert nicht." Es gibt offensichtlich ein implizites "Kann mir jemand bitte einige Hinweise geben?" Im Gegensatz zu vielen Hausaufgabenfragen ist diese (a) gut geschrieben, (b) ist offen, wenn es um Hausaufgaben geht, und (c) beinhaltet einen guten Versuch, das Problem zu lösen. Ich denke nicht, dass das Fehlen eines tatsächlichen Fragezeichens zu stark ablenkt.
John Fouhy
36
Die Blasensortierung wird als Lernwerkzeug verwendet, da sie für die meisten Menschen am einfachsten zu verstehen ist. Es ist ein guter Einstiegspunkt, um etwas über Sortierung und Algorithmen im Allgemeinen zu lernen. Wenn wir nur Dinge unterrichten würden, die die Leute tatsächlich verwenden würden, würde die Diskussion über das Sortieren mit "Verwenden der Bibliothekssortierroutine" beginnen und enden.
Bill the Lizard
38
Diese Frage ist ein Aushängeschild dafür, wie man gute "Hausaufgaben" stellt. Zu John Fouhys Punkt gibt es ein Codebeispiel, es ist gut geschrieben und das Poster ist bemüht, es uns leicht zu machen, zu helfen. Gut gemacht, Joshhunt.
Jarret Hardie
20
Die Blasensortierung ist kein leicht zu verstehender Sortieralgorithmus. Sowohl aus meiner eigenen Erfahrung als auch aus meiner Erfahrung im Unterrichten kann ich mit Sicherheit sagen, dass Einfügesortierung, Auswahlsortierung, Min-Sortierung (minimale Elementsortierung), sogar (für einige Schüler) Mergesort und Quicksort leichter zu verstehen sind - schließlich entsprechen sie etwas natürliche Arten, eine Liste zu sortieren, aber die Blasensortierung ist nur künstlich. Darüber hinaus ist die Blasensortierung anfällig für viele Fehler nacheinander und Endlosschleifenfehler, wie diese Frage hier. Wie Knuth sagt, "scheint die
Blasensorte

Antworten:

127

Um zu erklären, warum Ihr Skript gerade nicht funktioniert, benenne ich die Variable unsortedin um sorted.

Ihre Liste ist zunächst noch nicht sortiert. Natürlich machen wir uns sorteddaran False.

Sobald wir die whileSchleife starten , gehen wir davon aus, dass die Liste bereits sortiert ist. Die Idee ist folgende: Sobald wir zwei Elemente finden, die nicht in der richtigen Reihenfolge sind, kehren wir sortedzurück False. sortedwird True nur bleiben , wenn es keine Elemente in der falschen Reihenfolge gab .

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.

Es gibt auch kleinere kleine Probleme, die dazu beitragen würden, dass der Code effizienter oder lesbarer wird.

  • In der forSchleife verwenden Sie die Variable element. Technisch elementist kein Element; Es ist eine Zahl, die einen Listenindex darstellt. Außerdem ist es ziemlich lang. Verwenden Sie in diesen Fällen einfach einen temporären Variablennamen, z. B. ifür "Index".

    for i in range(0, length):
  • Der rangeBefehl kann auch nur ein Argument (benannt stop) annehmen . In diesem Fall erhalten Sie eine Liste aller Ganzzahlen von 0 bis zu diesem Argument.

    for i in range(length):
  • Der Python Style Guide empfiehlt, Variablen in Kleinbuchstaben mit Unterstrichen zu benennen. Dies ist ein sehr kleiner Trottel für ein kleines Skript wie dieses; Es ist mehr, um Sie an den Python-Code zu gewöhnen, der am häufigsten ähnelt.

    def bubble(bad_list):
  • Um die Werte zweier Variablen auszutauschen, schreiben Sie sie als Tupelzuweisung. Die rechte Seite wird als Tupel ausgewertet (z. B. (badList[i+1], badList[i])ist (3, 5)) und dann den beiden Variablen auf der linken Seite zugewiesen ( (badList[i], badList[i+1])).

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

Füge alles zusammen und du bekommst folgendes:

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

(Ich habe übrigens auch Ihre Druckerklärung entfernt.)

Wesley
quelle
1
Nur bei diesem letzten Code gibt die Blase nichts zurück. Das Endergebnis ist also, dass "Keine" gedruckt wird. Sie möchten wahrscheinlich entweder die Liste zurückgeben oder eine Blase (my_list) erstellen und dann my_list drucken.
Tung Nguyen
9
+1 gut strukturierte, klare Beratung. Schön zu sehen, dass Sie den Leser durch das führen, was Sie getan haben und warum, anstatt nur eine schnelle Lösung zu schreiben.
Tom Leys
1
Ich bin ein C # -Programmierer, also könnte dies nur daran liegen, dass ich kein Python bekomme, aber brauchen Sie nicht etwas in der while-Schleife, um 1 von der Länge zu subtrahieren, um einen normalen Blasensortierungsalgorithmus zu erhalten?
Martin Brown
20
Dies ist eine naive (aber nicht falsche) Implementierung von Bubble Sort. Nach jeder Iteration der whileSchleife "sprudelt" das größte Element bis zum Ende der Liste. Daher befindet sich das letzte Element nach einer Iteration definitiv an der richtigen Stelle (und wird durch aufeinanderfolgende Iterationen nicht verschoben). Durch Subtrahieren von 1 von der Länge optimieren Sie den Algorithmus, indem Sie nur die noch nicht sortierte Unterliste sortieren (die length-nvordersten Elemente der Liste). Ich habe mich entschieden, diese Optimierung zu überspringen, da sie eher eine Optimierung als ein wesentlicher Bestandteil des Algorithmus ist.
Wesley
2
Put it all together, and you get this:... nun, du hast diesen verpasst:The range command can also take just one argument (named stop).
Peter Perháč
10

Das Ziel der Blasensortierung ist es, die schwereren Gegenstände in jeder Runde unten zu bewegen , während die leichteren Gegenstände nach oben bewegt werden. In der inneren Schleife, in der Sie die Elemente vergleichen, müssen Sie nicht in jeder Runde die gesamte Liste durchlaufen . Der schwerste ist bereits zuletzt platziert. Die ausgetauschte Variable ist eine zusätzliche Prüfung, damit wir markieren können, dass die Liste jetzt sortiert ist, und vermeiden, mit unnötigen Berechnungen fortzufahren.

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

Ihre Version 1, korrigiert:

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
Nick Dandoulakis
quelle
8

Dies passiert, wenn Sie einen Variablennamen mit negativer Bedeutung verwenden und dessen Werte invertieren müssen. Folgendes wäre leichter zu verstehen:

sorted = False
while not sorted:
    ...

Andererseits ist die Logik des Algorithmus etwas abweichend. Sie müssen überprüfen, ob zwei Elemente während der for-Schleife ausgetauscht wurden. So würde ich es schreiben:

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
Martin Cote
quelle
1
Es ist ein bisschen schade, dass es keinen "FALSCHEN" Knopf gibt, den ich für diese Antwort drücken kann. Ich denke, diese Frage und die Antworten - und insbesondere die Abstimmung - müssen das nächste Mal vorgestellt werden, wenn Joel Spolsky darüber spricht, wie gut er die sozialen Interaktionen beim Stackoverflow abgestimmt hat.
Daniel Martin
@ Daniel: Sie können das tun, was andere Leute mit genügend Ruf (100) tun können - die falsche Antwort ablehnen. Es gibt einen Keim der Wahrheit - negierte Bedingungen, die in Flag-Variablen verankert sind, sind schlecht. Es ist jedoch nicht die ganze Antwort - @McWafflestix hat es richtig, denke ich.
Jonathan Leffler
2
Ihr habt Recht, antwortete ich vorzeitig. Das tut mir leid.
Martin Cote
2
@ Martin - und ich sollte darauf hinweisen, dass mich die Abstimmung mehr überrascht / schockiert als die Antwort. Das Reputationssystem ermutigt Sie, diese erste Antwort sofort zu erhalten. Der fehlerhafte Teil ist, wie eine falsche Antwort abgestimmt wird.
Daniel Martin
2
Ich vermute, dass die meisten Menschen wählen, ohne die Frage überhaupt zu verstehen (genau wie ich die Frage beantwortet habe). OTOH, die Person, die die Frage stellt, hat das Privileg, anschließend die „richtige“ Antwort zu wählen.
Martin Cote
7

Ihre Verwendung der unsortierten Variablen ist falsch. Sie möchten eine Variable haben, die Ihnen sagt, ob Sie zwei Elemente ausgetauscht haben. Wenn Sie dies getan haben, können Sie Ihre Schleife verlassen, andernfalls müssen Sie die Schleife erneut durchführen. Um zu korrigieren, was Sie hier haben, fügen Sie einfach "unsortiert = falsch" in den Text Ihres if-Falls ein. Entfernen Sie Ihren anderen Fall. und setzen Sie "unsorted = true" vor Ihre forSchleife.

Paul Sonier
quelle
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
mtasic85
quelle
1
Ich glaube, die Frage war eher im Sinne von "Wie kann dieser Code repariert werden?" Und nicht "Was ist Ihre Blasensorte?".
Josh Hunt
4
Sie haben absolut Recht, aber es ist wichtiger, es richtig zu machen
mtasic85
6
Richtig, vielleicht mtasisch ... aber alles, was als Hausaufgabe gekennzeichnet ist, wird am lehrreichsten optimiert und nicht neu geschrieben (insbesondere, wenn es vom OP als Hausaufgabe gekennzeichnet wird).
Jarret Hardie
1
Dies ist eine perfekte Neufassung des Lehrbuchs C Blasensorte, die die meisten Menschen studieren. Ich habe das gleiche geschrieben.
Lakshman Prasad
2
Das Hinzufügen guter Informationen ist meiner Ansicht nach hilfreich. so gute Antwort .. dachte, Sie könnten Flagge verwenden, um so früh wie möglich zu brechen.
Grijesh Chauhan
3

# Eine sehr einfache Funktion, die (offensichtlich) optimiert werden kann, indem der Problembereich des 2. Arrays verringert wird. Aber gleiche O (n ^ 2) -Komplexität.

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 
Waqas
quelle
Die Art und Weise, wie Sie Werte in Python austauschen können, ist etwas weniger aufwändig: arr[a], arr[b] = arr[b], arr[a]
Makoto
1

Sie haben ein paar Fehler drin. Die erste ist lang und die zweite wird von unsortiert verwendet (wie von McWafflestix angegeben). Sie möchten die Liste wahrscheinlich auch zurückgeben, wenn Sie sie drucken möchten:

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: Du hast recht, das obige ist verdammt fehlerhaft. Mein schlechtes, weil ich nicht durch einige weitere Beispiele getestet habe.

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
Trevor Oke
quelle
Sollte das "unsortiert = falsch" nicht außerhalb der for-Schleife liegen?
Svante
Es hatte ein paar mehr Probleme als das;)
Trevor Oke
1

Ich bin ein frischer Anfänger und habe gestern angefangen, über Python zu lesen. Inspiriert von Ihrem Beispiel habe ich etwas geschaffen, das vielleicht mehr im 80er-Jahre-Stil ist, aber trotzdem funktioniert es irgendwie

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)
Igor
quelle
1

Das Problem mit dem ursprünglichen Algorithmus ist, dass wenn Sie eine niedrigere Zahl weiter in der Liste hätten, diese nicht an die richtige sortierte Position gebracht würde. Das Programm muss jedes Mal den Anfang zurückgehen, um sicherzustellen, dass die Zahlen vollständig sortiert sind.

Ich habe den Code vereinfacht und er funktioniert jetzt für jede Liste von Zahlen, unabhängig von der Liste und selbst wenn sich Zahlen wiederholen. Hier ist der Code

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)
weinberg
quelle
1
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
Zile Rehman
quelle
1
Blasen Sie ein größeres Element bis zum Ende. Und dekrementieren Sie den Endzähler "n", damit Sie ihn nicht erneut vergleichen müssen. Fahren Sie mit der while-Schleife fort, solange ein Austausch stattfindet. Schlimmster Fall: O (N ^ 2) Bester Fall: O (N)
Zile Rehman
1
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

alist = [54,26,93,17,77,31,44,55,20, -23, -34,16,11,11,11]

print bubleSort (alist)

pythonnewbie
quelle
Bitte rücken Sie Ihr Codebeispiel richtig ein: Dies ist natürlich in Python besonders wichtig. Vielleicht möchten Sie auch erklären, warum Ihre Lösung eine Überlegung wert ist, wenn man bedenkt, dass es auch eine Antwort mit 100 Stimmen gibt
kdopen
1
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
Pinkopink
quelle
1

Ein einfacheres Beispiel:

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

Dies nimmt einfach die Elemente von 0 nach a (im Grunde alle unsortierten Elemente in dieser Runde) und vergleicht sie mit dem benachbarten Element und führt einen Swap durch, wenn sie größer als das benachbarte Element sind. Am Ende der Runde wird das letzte Element sortiert und der Prozess wird erneut ohne dieses Element ausgeführt, bis alle Elemente sortiert wurden.

Es besteht keine Notwendigkeit für eine Bedingung, ob sie sortwahr ist oder nicht.

Beachten Sie, dass dieser Algorithmus die Position der Zahlen nur beim Tauschen berücksichtigt, sodass wiederholte Zahlen keine Auswirkungen darauf haben.

PS. Ich weiß, dass es sehr lange her ist, dass diese Frage gestellt wurde, aber ich wollte diese Idee nur teilen.

txsaw1
quelle
1
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)
sim
quelle
0
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
Felsig
quelle
0
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 )
aldo núñez
quelle
0
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]))
Luke Willey
quelle
1
Während dieser Code die Frage möglicherweise beantwortet, würde die Bereitstellung eines zusätzlichen Kontexts darüber, wie und / oder warum das Problem gelöst wird, den langfristigen Wert der Antwort verbessern.
Alexander
0

Ich denke darüber nach, meine Lösung hinzuzufügen, weil es hier jemals eine Lösung gibt

  1. größere Zeit
  2. größere Raumkomplexität
  3. oder zu viele Operationen ausführen

dann sollte es sein

Also, hier ist meine Lösung:


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
Akshat Tamrakar
quelle
0

Wenn jemand an einer kürzeren Implementierung mit Listenverständnis interessiert ist:

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]
Liram Zarrouk
quelle
0

Hier ist eine andere Variante der Blasensortierung ohne forSchleife. Grundsätzlich betrachten Sie das lastIndexvon arrayund langsam decrementingbis zum ersten Index des Arrays.

Der algorithmwird sich so weiter durch das Array bewegen, bis ein vollständiger Durchlauf ohne swapsAuftreten erfolgt ist.

Die Blase ist im Grunde genommen eine Art Quadratic Time: O(n²)Leistung.

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())
Thalaivar
quelle
-1

Die Antworten von the-fury und Martin Cote haben das Problem der Endlosschleife behoben, aber mein Code würde immer noch nicht richtig funktionieren (für eine größere Liste würde er nicht richtig sortieren.). Am Ende habe ich die unsortedVariable verworfen und stattdessen einen Zähler verwendet.

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)

Wenn jemand in den Kommentaren Hinweise geben könnte, wie ich meinen Code verbessern kann, wäre ich sehr dankbar.

Josh Hunt
quelle
Sie können eine Blasensortierung beschleunigen, indem Sie den Teil Ihrer Liste überspringen, von dem Sie wissen, dass er bereits sortiert ist (aufgrund früherer Iterationen). Siehe en.wikipedia.org/wiki/Bubble_sort#Alternative_implementations
Blorgbeard erscheint
3
Auch hier müssen Sie nur einen Booleschen Wert verwenden (nennen Sie ihn unberührt). deklarieren Sie es außerhalb Ihrer Schleife; Schleife bis unberührt = wahr. Setzen Sie in Ihrer while-Schleife unberührt, um wahr zu sein. Setzen Sie im Körper Ihres Wenn unberührt, um falsch zu sein. Auf diese Weise können Sie Ihren anderen Fall fallen lassen. Auf diese Weise wird Ihre Schleife fortgesetzt, wenn Sie jemals zwei Elemente wechseln. Wenn Sie dies nicht tun, wird die Schleife nicht.
Paul Sonier
-1

Versuche dies

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)
vivek shinde
quelle
-1

idk, wenn dir das nach 9 Jahren helfen könnte ... es ist ein einfaches Programm zum Sortieren von Blasen

    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]
Carl
quelle
-1
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 
user11689497
quelle
-1
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
Amandeep Singh
quelle
Es ist besser, Ihrem Code eine Erklärung hinzuzufügen.
Masoud Rahimi
-1
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]
Ruffy
quelle
-3

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

Nik Radaev
quelle