Bubble Sort Homework

In classe stiamo eseguendo algoritmi di ordinamento e, sebbene li capisca bene quando ne parlo e scrivo pseudocodice, ho problemi a scrivere codice reale per loro.

Questo è il mio tentativo 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)

Ora, questo (per quanto posso dire) si ordina in modo corretto, ma una volta terminato si gira a tempo indeterminato.

In che modo è possibile correggere questo codice in modo che la funzione termini correttamente e ordini correttamente un elenco di qualsiasi dimensione (ragionevole)?

PS So che non dovrei davvero avere stampe in una funzione e dovrei avere un ritorno, ma non l'ho ancora fatto dato che il mio codice non funziona ancora davvero.

Per spiegare perché il tuo script non funziona in questo momento, rinominerò la variabile unsortedin sorted.

Inizialmente, l'elenco non è stato ancora ordinato. Certo, ci siamo messi sorteda False.

Non appena iniziamo il whileciclo, supponiamo che l'elenco sia già ordinato. L'idea è questa: non appena troviamo due elementi che non sono nel giusto ordine, sortedtorniamo a False. sortedrimarrà True solo se non ci fossero elementi nell'ordine sbagliato .

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.

Ci sono anche piccoli piccoli problemi che potrebbero aiutare il codice a essere più efficiente o leggibile.

• Nel forciclo, usi la variabile element. Tecnicamente, elementnon è un elemento; è un numero che rappresenta un indice di elenco. Inoltre, è piuttosto lungo. In questi casi, basta usare un nome di variabile temporaneo, come iper "indice".

  for i in range(0, length):

• Il rangecomando può anche prendere solo un argomento (chiamato stop). In tal caso, si ottiene un elenco di tutti i numeri interi da 0 a tale argomento.

  for i in range(length):

• La Guida allo stile di Python raccomanda che le variabili siano nominate in minuscolo con caratteri di sottolineatura. Questo è un piccolo pignolo per una piccola sceneggiatura come questa; è più per abituarti a ciò che il codice Python assomiglia più spesso.

  def bubble(bad_list):

• Per scambiare i valori di due variabili, scriverli come assegnazione di tuple. Il lato destro viene valutato come una tupla (diciamo, (badList[i+1], badList[i])è (3, 5)) e quindi viene assegnato alle due variabili sul lato sinistro ( (badList[i], badList[i+1])).

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

Metti tutto insieme e ottieni questo:

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

(A proposito, ho rimosso anche la tua dichiarazione di stampa.)

L'obiettivo del bubble sort è di spostare gli oggetti più pesanti nella parte inferiore di ogni round, mentre si spostano gli oggetti più leggeri verso l' alto. Nel ciclo interno, in cui si confrontano gli elementi, non è necessario ripetere l'intero elenco in ogni turno . Il più pesante è già posizionato per ultimo. La variabile scambiata è un ulteriore controllo, quindi possiamo contrassegnare che l'elenco è ora ordinato ed evitare di continuare con calcoli non necessari.

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

La tua versione 1, corretta:

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

Questo è ciò che accade quando si utilizza il nome variabile di significato negativo, è necessario invertire i loro valori. Quanto segue sarebbe più facile da capire:

sorted = False
while not sorted:
    ...

D'altra parte, la logica dell'algoritmo è un po 'fuori. Devi verificare se due elementi sono stati scambiati durante il ciclo for. Ecco come lo scriverei:

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

L'uso della variabile Unsorted è errato; vuoi avere una variabile che ti dice se hai scambiato due elementi; se lo hai fatto, puoi uscire dal tuo loop, altrimenti devi ripetere il loop. Per correggere ciò che hai qui, inserisci semplicemente "unsorted = false" nel corpo del tuo caso if; rimuovi la tua altra custodia; e metti "unsorted = true prima del tuo forloop.

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

#Una funzione molto semplice, può essere ottimizzata (ovviamente) diminuendo lo spazio problematico del 2 ° array. Ma stessa complessità O (n ^ 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 

Ci sono un paio di errori lì dentro. Il primo è lungo e il secondo è nell'uso di non ordinati (come affermato da McWafflestix). Probabilmente vuoi anche restituire l'elenco se hai intenzione di stamparlo:

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: hai ragione, quanto sopra è buggy da morire. Il mio male per non aver testato alcuni altri esempi.

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

Sono un nuovo principiante, ho iniziato a leggere su Python ieri. Ispirato dal tuo esempio, ho creato qualcosa di forse di più nello stile degli 80 legami, ma comunque funziona

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)

Il problema con l'algoritmo originale è che se avessi un numero più basso nell'elenco, non lo porterebbe nella posizione ordinata corretta. Il programma deve tornare all'inizio ogni volta per garantire che i numeri vengano ordinati fino in fondo.

Ho semplificato il codice e ora funzionerà per qualsiasi elenco di numeri indipendentemente dall'elenco e anche se ci sono numeri che si ripetono. Ecco il codice

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]

stampa bubbleSort (elenco)

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

Un esempio più semplice:

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

Questo semplicemente prende gli elementi da 0 a a (sostanzialmente, tutti gli elementi non ordinati in quel round) e li confronta con il suo elemento adiacente, e fa uno scambio se è maggiore del suo elemento adiacente. Alla fine del round, l'ultimo elemento viene ordinato e il processo viene eseguito nuovamente senza di esso, fino a quando tutti gli elementi non sono stati ordinati.

Non è necessario che una condizione sia sortvera o no.

Si noti che questo algoritmo prende in considerazione la posizione dei numeri solo durante lo scambio, quindi i numeri ripetuti non lo influenzeranno.

PS. So che è passato molto tempo da quando questa domanda è stata pubblicata, ma volevo solo condividere questa idea.

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

Considero l'aggiunta della mia soluzione perché la soluzione qui sta avendo

1. tempo maggiore
2. maggiore complessità spaziale
3. o fare troppe operazioni

allora dovrebbe essere

Quindi, ecco la mia soluzione:

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

Se qualcuno è interessato a un'implementazione più breve usando una comprensione dell'elenco:

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]

Ecco una diversa variante di ordinamento a bolle senza forloop. Fondamentalmente si sta valutando la lastIndexdel arraye lentamente decrementingfinché non primo indice dell'array.

L' algorithmcontinuerà a muoversi attraverso la matrice così fino un'intera passaggio avviene senza alcun swapsverifichi.

La bolla è una specie è fondamentalmente Quadratic Time: O(n²)quando si tratta di prestazioni.

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

Le risposte fornite da the-fury e Martin Cote hanno risolto il problema del ciclo infinito, ma il mio codice non funzionava ancora correttamente (per un elenco più ampio, non si ordinava correttamente). Ho finito per abbandonare la unsortedvariabile e invece ho usato un contatore.

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)

Se qualcuno potesse fornire qualche suggerimento su come migliorare il mio codice nei commenti, sarebbe molto apprezzato.

Prova questo

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 se questo potrebbe aiutarti dopo 9 anni ... è un semplice programma di ordinamento delle bolle

    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