Pekerjaan Rumah Sortir Bubble

Di kelas kami melakukan pengurutan algoritma dan, meskipun saya mengerti mereka baik-baik saja ketika berbicara tentang mereka dan menulis pseudocode, saya mengalami masalah dalam menulis kode aktual untuk mereka.

Ini adalah usaha saya di 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)

Sekarang, ini (sejauh yang saya tahu) dapat diurutkan dengan benar, tetapi setelah selesai, hanya loop tanpa batas.

Bagaimana kode ini diperbaiki sehingga fungsi selesai dengan benar dan benar mengurutkan daftar ukuran apa pun (masuk akal)?

PS Saya tahu saya seharusnya tidak benar-benar memiliki cetakan dalam suatu fungsi dan saya harus kembali, tetapi saya belum melakukan itu karena kode saya belum benar-benar berfungsi.

Untuk menjelaskan mengapa skrip Anda tidak berfungsi saat ini, saya akan mengganti nama variabel unsortedmenjadi sorted.

Pada awalnya, daftar Anda belum diurutkan. Tentu saja, kami mengatur sorteduntuk False.

Segera setelah kami memulai whileloop, kami menganggap bahwa daftar sudah diurutkan. Idenya adalah ini: begitu kita menemukan dua elemen yang tidak dalam urutan yang benar, kita sortedkembali ke False. sortedakan tetap True hanya jika tidak ada elemen dalam urutan yang salah .

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.

Ada juga masalah kecil kecil yang akan membantu kode menjadi lebih efisien atau mudah dibaca.

• Dalam forlingkaran, Anda menggunakan variabel element. Secara teknis, elementbukan elemen; itu nomor yang mewakili indeks daftar. Juga, ini cukup panjang. Dalam kasus ini, cukup gunakan nama variabel sementara, seperti iuntuk "indeks".

  for i in range(0, length):

• The rangeperintah juga dapat mengambil hanya satu argumen (bernama stop). Dalam hal ini, Anda mendapatkan daftar semua bilangan bulat dari 0 hingga argumen itu.

  for i in range(length):

• The Python Style Guide merekomendasikan bahwa variabel diberi nama dalam huruf kecil dengan garis bawah. Ini adalah nitpick yang sangat kecil untuk skrip kecil seperti ini; itu lebih untuk membuat Anda terbiasa dengan apa yang paling mirip dengan kode Python.

  def bubble(bad_list):

• Untuk menukar nilai dua variabel, tulislah sebagai tugas tuple. Sisi kanan akan dievaluasi sebagai tupel (katakanlah, (badList[i+1], badList[i])adalah (3, 5)) dan kemudian ditugaskan ke dua variabel di sisi kiri ( (badList[i], badList[i+1])).

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

Kumpulkan semuanya, dan Anda mendapatkan ini:

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

(Omong-omong, saya menghapus pernyataan cetak Anda.)

Tujuan dari semacam bubble adalah untuk memindahkan item yang lebih berat di bagian bawah di setiap putaran, sambil memindahkan item yang lebih ringan ke atas. Di loop dalam, di mana Anda membandingkan elemen, Anda tidak perlu mengulangi seluruh daftar di setiap belokan . Yang terberat sudah ditempatkan terakhir. The bertukar variabel pemeriksaan tambahan sehingga kita bisa menandai bahwa daftar sekarang diurutkan dan menghindari melanjutkan dengan perhitungan yang tidak perlu.

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

Versi 1 Anda, diperbaiki:

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

Inilah yang terjadi ketika Anda menggunakan nama variabel makna negatif, Anda perlu membalikkan nilainya. Berikut ini akan lebih mudah dipahami:

sorted = False
while not sorted:
    ...

Di sisi lain, logika algoritme sedikit tidak aktif. Anda perlu memeriksa apakah dua elemen bertukar selama for loop. Begini cara saya menulisnya:

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

Penggunaan Anda atas variabel Tidak Disortir salah; Anda ingin memiliki variabel yang memberi tahu Anda jika Anda telah bertukar dua elemen; jika Anda telah melakukannya, Anda dapat keluar dari loop, jika tidak, Anda perlu mengulang lagi. Untuk memperbaiki apa yang Anda dapatkan di sini, cukup masukkan "unsorted = false" di badan case Anda; hapus kasus Anda yang lain; dan masukkan "unsorted = true sebelum forloop Anda .

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

Fungsi #A yang sangat sederhana, dapat dioptimalkan (jelas) dengan mengurangi ruang masalah array ke-2. Tetapi kompleksitas O (n ^ 2) yang sama.

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 

Ada beberapa kesalahan di sana. Yang pertama panjang, dan yang kedua dalam penggunaan Anda tidak disortir (seperti yang dinyatakan oleh McWafflestix). Anda mungkin juga ingin mengembalikan daftar jika Anda ingin mencetaknya:

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: Kamu benar, yang di atas buggy sekali. Saya buruk karena tidak menguji melalui beberapa contoh lagi.

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

Saya seorang pemula yang segar, mulai membaca tentang Python kemarin. Terinspirasi oleh teladan Anda, saya menciptakan sesuatu yang mungkin lebih bergaya 80-ties, tapi tetap saja berhasil

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)

Masalah dengan algoritma asli adalah bahwa jika Anda memiliki angka lebih rendah dalam daftar, itu tidak akan membawanya ke posisi yang diurutkan dengan benar. Program harus kembali ke awal setiap kali untuk memastikan bahwa angka-angka menyortir semua jalan.

Saya menyederhanakan kode dan sekarang akan berfungsi untuk daftar nomor apa pun terlepas dari daftar dan bahkan jika ada nomor yang berulang. Ini kodenya

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

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

Contoh sederhana:

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

Ini hanya mengambil elemen dari 0 ke a (pada dasarnya, semua elemen yang tidak disortir dalam putaran itu) dan membandingkannya dengan elemen yang berdekatan, dan membuat swap jika lebih besar dari elemen yang berdekatan. Pada akhir putaran, elemen terakhir diurutkan, dan proses berjalan lagi tanpanya, sampai semua elemen telah diurutkan.

Tidak perlu untuk suatu kondisi apakah sortitu benar atau tidak.

Perhatikan bahwa algoritma ini mempertimbangkan posisi angka hanya ketika bertukar, sehingga angka yang diulang tidak akan mempengaruhinya.

PS. Saya tahu sudah sangat lama sejak pertanyaan ini diposting, tetapi saya hanya ingin membagikan ide ini.

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

Saya mempertimbangkan untuk menambahkan solusi saya karena solusi yang pernah ada di sini

1. waktu yang lebih besar
2. kompleksitas ruang yang lebih besar
3. atau melakukan terlalu banyak operasi

maka seharusnya

Jadi, inilah solusi saya:

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

Jika ada yang tertarik dengan implementasi yang lebih pendek menggunakan pemahaman daftar:

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]

Berikut adalah variasi berbeda dari jenis gelembung tanpa forloop. Pada dasarnya Anda sedang mempertimbangkan lastIndexdari arraydan perlahan-lahan decrementingitu sampai indeks pertama dari array.

The algorithmakan terus bergerak melalui array seperti ini sampai seluruh lulus dibuat tanpa swapsterjadi.

Gelembung adalah semacam pada dasarnya Quadratic Time: O(n²)ketika datang ke kinerja.

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

Jawaban yang diberikan oleh the fury dan Martin Cote memperbaiki masalah loop infinite, tetapi kode saya masih tidak berfungsi dengan benar (untuk daftar yang lebih besar, itu tidak akan diurutkan dengan benar.). Saya akhirnya membuang unsortedvariabel dan menggunakan penghitung.

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)

Jika ada yang bisa memberikan petunjuk tentang cara meningkatkan kode saya di komentar, itu akan sangat dihargai.

Coba ini

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 jika ini dapat membantu Anda setelah 9 tahun ... ini adalah program semacam gelembung sederhana

    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