Kabarcık Sıralama Ödev

Sınıfta sıralama algoritmaları yapıyoruz ve onlar hakkında konuşurken ve sözde kod yazarken onları iyi anlasam da, onlar için gerçek kod yazarken sorun yaşıyorum.

Bu benim Python'daki girişimim:

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)

Şimdi, bu (söyleyebildiğim kadarıyla) doğru sıralıyor, ancak bittiğinde süresiz olarak dönüyor.

Bu kod nasıl düzeltilebilir, böylece işlev düzgün bir şekilde tamamlanır ve herhangi bir (makul) boyuttaki bir listeyi doğru şekilde sıralar?

Not: Bir işlevde gerçekten baskılara sahip olmamam gerektiğini ve bir dönüş almam gerektiğini biliyorum, ancak kodum henüz gerçekten çalışmadığı için bunu henüz yapmadım.

Betiğinizin neden şu anda çalışmadığını açıklamak için, değişkeni unsortedolarak yeniden adlandıracağım sorted.

İlk başta, listeniz henüz sıralanmamış. Tabii ki, biz ayarlamak sortediçin False.

Döngüye başlar başlamaz while, listenin zaten sıralandığını varsayıyoruz. Fikir şudur: Doğru sırada olmayan iki öğe bulduğumuzda, sortedgeri dönüyoruz False. yalnızca yanlış sırada hiçbir öğe yoksasorted kalır .True

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.

Kodun daha verimli veya okunabilir olmasına yardımcı olacak küçük küçük sorunlar da vardır.

• In fordöngü, sen değişken kullanabilirsiniz element. Teknik olarak elementbir unsur değildir; bir liste dizinini temsil eden bir sayıdır. Ayrıca oldukça uzun. Bu durumlarda, i"dizin" gibi geçici bir değişken adı kullanın .

  for i in range(0, length):

• rangeKomut ayrıca (adında sadece bir argüman alabilir stop). Bu durumda, 0'dan o bağımsız değişkene kadar tüm tam sayıların bir listesini alırsınız.

  for i in range(length):

• Python Stil Kılavuzu değişkenleri alt çizgilerle küçük harflerle adlandırılmış önerir. Bu, bunun gibi küçük bir betik için çok küçük bir olaydır; daha çok Python kodunun neye benzediğine alışmanızı sağlamaktır.

  def bubble(bad_list):

• İki değişkenin değerlerini takas etmek için, bunları bir demet ataması olarak yazın. Sağ taraftaki bir demet olarak değerlendirilir (diyelim ki, alır (badList[i+1], badList[i])ise (3, 5)sol tarafta iki değişkene atanır sonra) ve ( (badList[i], badList[i+1])).

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

Hepsini bir araya getirin ve şunu elde edin:

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

(Bu arada, basılı ifadeni de kaldırdım.)

Kabarcık sıralamanın amacı, daha hafif öğeleri yukarı hareket ettirirken her turda alttaki daha ağır öğeleri hareket ettirmektir . Öğeleri karşılaştırdığınız iç döngüde, her seferinde tüm listeyi yinelemek zorunda değilsiniz . En ağır olan zaten en sona yerleştirildi. Takas biz listesi şimdi sıralandığını işaretlemek ve gereksiz hesaplamaları ile devam önlemek, böylece değişken ekstra bir kontroldür.

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

Sürüm 1'iniz düzeltildi:

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

Negatif anlam değişken adını kullandığınızda olan budur, değerlerini tersine çevirmeniz gerekir. Aşağıdakileri anlamak daha kolay olacaktır:

sorted = False
while not sorted:
    ...

Öte yandan, algoritmanın mantığı biraz yanlış. For döngüsü sırasında iki öğenin yer değiştirip değiştirmediğini kontrol etmeniz gerekir. İşte bunu nasıl yazacağım:

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

Sıralanmamış değişken kullanımınız yanlıştır; iki öğeyi değiştirip değiştirmediğinizi söyleyen bir değişkene sahip olmak istiyorsunuz; Eğer bunu yaptıysanız, döngünüzden çıkabilirsiniz, aksi takdirde tekrar döngü yapmanız gerekir. Burada sahip olduklarınızı düzeltmek için, if durumunuzun gövdesine "sıralanmamış = yanlış" yazın; senin başka davanı kaldır; ve döngünüzden önce "sıralanmamış = doğru" yazın for.

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

# Çok basit bir fonksiyon, 2. dizinin problem alanını azaltarak (tabii ki) optimize edilebilir. Ama aynı O (n ^ 2) karmaşıklığı.

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 

Orada birkaç hata var. Birincisi uzunluktadır ve ikincisi, sıralanmamış kullanımınız içindir (McWafflestix tarafından belirtildiği gibi). Muhtemelen yazdıracaksanız listeyi de iade etmek istersiniz:

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: Haklısın, yukarıdaki cehennem gibi adamcağız. Daha fazla örnekle test etmemek benim hatam.

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

Yepyeni bir acemiyim, dün Python hakkında okumaya başladım. Örneğinizden esinlenerek 80 kravat tarzında bir şey yarattım ama yine de işe yarıyor

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)

Orijinal algoritmadaki sorun, listede daha düşük bir sayıya sahipseniz, onu doğru sıralanmış konuma getirmeyeceğidir. Sayıların baştan sona sıralandığından emin olmak için programın her seferinde başlangıca geri gitmesi gerekir.

Kodu basitleştirdim ve artık listeden bağımsız olarak ve tekrar eden numaralar olsa bile herhangi bir sayı listesi için çalışacak. İşte kod

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]

yazdırma balonuSort (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

Daha basit bir örnek:

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

Bu basitçe öğeleri 0'dan a'ya alır (temelde o turdaki tüm sıralanmamış öğeler) ve onu bitişiğindeki öğesiyle karşılaştırır ve bitişiğindeki öğesinden büyükse bir takas yapar. Turun sonunda, son öğe sıralanır ve tüm öğeler sıralanana kadar süreç onsuz tekrar çalışır.

sortDoğru olsun ya da olmasın herhangi bir koşula ihtiyaç yoktur .

Bu algoritmanın sadece yer değiştirirken sayıların konumunu dikkate aldığını, dolayısıyla tekrarlanan sayıların onu etkilemeyeceğini unutmayın.

PS. Bu sorunun gönderilmesinden bu yana çok uzun zaman geçtiğini biliyorum ama sadece bu fikri paylaşmak istedim.

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

Çözümümü eklemeyi düşünüyorum çünkü buradaki her çözüm,

1. daha fazla zaman
2. daha fazla alan karmaşıklığı
3. veya çok fazla işlem yapmak

o zaman olmalı

İşte benim çözümüm:

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

Bir liste anlama kullanarak daha kısa bir uygulama ile ilgilenen varsa:

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]

İşte fordöngü olmadan farklı bir balon sıralaması varyasyonu . Temelde Düşündüğünüz lastIndexarasında arrayve yavaşçadecrementing o dizinin ilk indeksi kadar.

algorithmBütün bir geçiş olmadan herhangi yapılır kadar böyle bir dizi boyunca hareket etmeye devam edecektir swapsmeydana gelebilmektedir.

Balon, Quadratic Time: O(n²)performans söz konusu olduğunda temelde çeşitlidir .

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

Öfke ve Martin Cote tarafından sağlanan yanıtlar sonsuz döngü sorununu çözdü, ancak kodum yine de düzgün çalışmıyordu (daha büyük bir liste için doğru sıralanmıyordu.). unsortedDeğişkeni atlattım ve bunun yerine bir sayaç kullandım.

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)

Herhangi biri yorumlarda kodumu nasıl geliştirebileceğime dair herhangi bir ipucu sağlayabilirse, çok memnun olur.

Bunu dene

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)

bu 9 yıl sonra size yardımcı olabilirse ... basit bir balonlu sıralama programı

    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