Pekerjaan Rumah Sortir Bubble

130

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.

Josh Hunt
sumber
29
@ KM - Haruskah dia mendapatkan halaman Anda?
Aiden Bell
123
Posting ini pada dasarnya: "Saya mengalami kesulitan coding, ini yang saya lakukan, tidak berfungsi." Jelas ada yang tersirat, "Bisakah seseorang memberi saya beberapa petunjuk?" Tidak seperti banyak pertanyaan pekerjaan rumah, ini (a) ditulis dengan baik, (b) dimuka tentang menjadi pekerjaan rumah, dan (c) termasuk upaya yang baik untuk menyelesaikan masalah. Saya tidak berpikir kurangnya mengurangi tanda tanya yang sebenarnya juga sangat ..
John Fouhy
36
Bubble sort digunakan sebagai alat pembelajaran karena merupakan algoritma pengurutan termudah yang dapat dipahami kebanyakan orang. Ini adalah titik masuk yang baik untuk belajar tentang penyortiran dan algoritma secara umum. Jika kita hanya mengajarkan hal-hal yang benar-benar akan digunakan orang, diskusi tentang penyortiran akan dimulai dan diakhiri dengan "gunakan rutin perpustakaan semacam".
Bill the Lizard
38
Pertanyaan ini adalah anak poster untuk bagaimana mengajukan pertanyaan "pekerjaan rumah" yang baik. Untuk poin John Fouhy, ada contoh kode, itu ditulis dengan baik, dan poster berusaha keras untuk memudahkan kita untuk membantu. Bagus sekali, joshhunt.
Jarret Hardie
20
Bubble sort bukanlah algoritma pengurutan yang mudah dipahami orang. Dari pengalaman saya sendiri dan pengalaman mengajar, saya dapat dengan yakin mengatakan bahwa jenis penyisipan, jenis pilihan, jenis-min (jenis elemen minimum), bahkan (untuk beberapa siswa) mergesort dan quicksort lebih mudah dipahami - setelah semua, mereka sesuai dengan agak cara alami menyortir daftar, tetapi semacam gelembung hanyalah buatan. Selanjutnya, semacam gelembung rentan terhadap banyak kesalahan satu per satu dan kesalahan loop tak terbatas, seperti pertanyaan ini di sini. Seperti Knuth mengatakan, "semacam gelembung tampaknya tidak merekomendasikan apa pun, kecuali nama yang mudah diingat ..."
ShreevatsaR

Jawaban:

127

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

Wesley
sumber
1
Hanya pada bit kode terakhir, gelembung tidak mengembalikan apa pun, sehingga hasil akhirnya adalah 'Tidak Ada' yang dicetak. Anda mungkin ingin mengembalikan daftar, atau melakukan gelembung (my_list) dan kemudian mencetak my_list.
Tung Nguyen
9
+1 saran terstruktur dengan baik, jelas. Senang melihat Anda memandu pembaca membaca apa yang Anda lakukan dan mengapa daripada hanya menulis perbaikan cepat.
Tom Leys
1
Saya seorang programmer C #, jadi ini mungkin saja karena saya tidak mendapatkan Python, tetapi tidakkah Anda memerlukan sesuatu di loop sementara untuk mengurangi 1 dari panjang untuk mendapatkan algoritma pengurutan gelembung yang normal?
Martin Brown
20
Ini adalah implementasi Bubble Sort yang naif (tapi tidak salah). Setelah setiap iterasi dari whileloop, elemen terbesar "menggembung" ke akhir daftar. Dengan demikian, setelah satu iterasi, elemen terakhir pasti ada di tempat yang tepat (dan tidak akan tergerak oleh iterasi yang berurutan). Dengan mengurangi 1 dari panjang, Anda mengoptimalkan algoritme dengan hanya mengurutkan sublist yang belum diurutkan ( length-nelemen paling depan dari daftar). Saya memilih untuk melewati optimasi ini, karena ini lebih merupakan optimasi daripada bagian vital dari algoritma.
Wesley
2
Put it all together, and you get this:... well, Anda melewatkan yang satu ini:The range command can also take just one argument (named stop).
Peter Perháč
10

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

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
Martin Cote
sumber
1
Agak terlalu buruk tidak ada tombol "SALAH" yang bisa saya tekan untuk jawaban ini. Saya pikir pertanyaan ini dan jawabannya - dan terutama pemungutan suara - perlu ditampilkan di lain waktu ketika Joel Spolsky berbicara tentang seberapa baik dia menyelaraskan interaksi sosial pada stackoverflow.
Daniel Martin
@Aniel: Anda dapat melakukan apa yang dapat dilakukan orang lain dengan reputasi cukup (100) - menurunkan jawaban yang salah. Ada kuman kebenaran - kondisi yang dinegasikan yang diabadikan dalam variabel flag adalah buruk. Bukan seluruh jawaban, - @McWafflestix benar, saya pikir.
Jonathan Leffler
2
Kalian benar, saya menjawab prematur untuk yang satu ini. Maaf soal itu.
Martin Cote
2
@ Martin - dan saya harus menunjukkan bahwa saya lebih terkejut / terkejut dengan pemungutan suara daripada jawabannya. Sistem reputasi mendorong Anda untuk mendapatkan jawaban pertama itu, segera. Bagian yang rusak adalah bagaimana jawaban yang salah dipilih.
Daniel Martin
2
Saya menduga bahwa kebanyakan orang memilih tanpa benar-benar memahami pertanyaan pada awalnya (seperti cara saya menjawab pertanyaan). OTOH, orang yang mengajukan pertanyaan memiliki hak istimewa untuk memilih jawaban yang 'benar' sesudahnya.
Martin Cote
7

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 .

Paul Sonier
sumber
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
sumber
1
Saya yakin pertanyaannya lebih pada baris 'Bagaimana kode ini bisa diperbaiki', bukan 'apa jenis gelembung Anda?'
Josh Hunt
4
Anda memang benar, tetapi melakukannya dengan cara yang benar adalah lebih penting
mtasic85
6
Benar, mungkin, mtasic ... tetapi apa pun yang ditandai sebagai pekerjaan rumah lebih baik diubah daripada ditulis ulang (terutama ketika itu ditandai sebagai pekerjaan rumah oleh OP).
Jarret Hardie
1
Ini adalah penulisan ulang yang sempurna dari buku teks C bubble sort yang dipelajari kebanyakan orang. Saya menulis yang sama.
Lakshman Prasad
2
menambahkan informasi yang baik sangat membantu dalam pandangan saya. jawaban yang sangat bagus .. meskipun Anda mungkin menggunakan flag untuk memecahkan sedini mungkin.
Grijesh Chauhan
3

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 
Waqas
sumber
Ini sedikit kurang rumit dengan cara Anda dapat menukar nilai dengan Python: arr[a], arr[b] = arr[b], arr[a]
Makoto
1

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
Trevor Oke
sumber
Tidakkah seharusnya "unsorted = False" berada di luar for for loop?
Svante
Ini memiliki lebih banyak masalah beberapa dari itu;)
Trevor Oke
1

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

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)
weinberg
sumber
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
sumber
1
Gelembung elemen yang lebih besar sampai akhir. Dan kurangi penghitung akhir, "n" sehingga Anda tidak perlu membandingkannya lagi. Lanjutkan dengan loop sementara selama ada pertukaran. Kasus Terburuk: O (N ^ 2) Kasus Terbaik: 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 bubbleSort (daftar)

pythonnewbie
sumber
Silakan inden contoh kode Anda dengan benar: ini, tentu saja, sangat penting dalam Python. Anda mungkin juga ingin menjelaskan mengapa solusi Anda layak dipertimbangkan mengingat ada juga jawaban dengan 100 suara
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
sumber
1

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.

txsaw1
sumber
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
sumber
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
Rocky
sumber
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
sumber
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
sumber
1
Sementara kode ini dapat menjawab pertanyaan, memberikan konteks tambahan tentang bagaimana dan / atau mengapa memecahkan masalah akan meningkatkan nilai jangka panjang jawaban.
Alexander
0

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

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

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

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.

Josh Hunt
sumber
Anda dapat mempercepat semacam gelembung dengan melewatkan bagian daftar Anda yang Anda tahu sudah diurutkan (karena iterasi sebelumnya). Lihat en.wikipedia.org/wiki/Bubble_sort#Alternative_implementations
Blorgbeard keluar
3
sekali lagi, yang perlu Anda lakukan hanyalah menggunakan boolean (sebut saja tidak tersentuh). mendeklarasikannya di luar loop Anda; lingkaran sampai tidak tersentuh = true. dalam loop sementara Anda, atur tersentuh untuk menjadi benar; di tubuh Anda jika, set tersentuh menjadi salah. Dengan melakukan ini, Anda dapat menyingkirkan kasus Anda yang lain. dengan cara ini, jika Anda pernah mengganti dua elemen, loop Anda akan berlanjut; jika tidak, loop tidak akan.
Paul Sonier
-1

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

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]
carl
sumber
-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 
pengguna11689497
sumber
-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
sumber
Akan lebih baik untuk menambahkan beberapa penjelasan ke kode Anda.
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]
Luffy
sumber
-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
sumber