Bubble Sort Hausaufgaben

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.

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.)

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

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

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.

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

# 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 

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

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)

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)

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

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)

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

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.

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)

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

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 )

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]))

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

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]

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())

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.

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)

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]

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 

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

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]

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