バブルソート課題

Question

クラスを行っていソートアルゴリズムは理解していて微細について語る時、書面擬似コード感を書く実際のコードです。

この試みは、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)

現在、この調査を実施しているのは、同じん)などを正しくだ終了でループを無期限に設定されています。

どのようにこのコードを固定しその機能が終了し、正確なリストの合理的な)大きさはどれくらいですか？

P.S.んになってプリント機能として返しがっていないことだと思ーコードリーダモードな仕事だ。

Answer 1

明らかにしていくスクリプトにな作業に、現在の私の名前の変更は、変数 unsorted へ sorted.

最初に、リストにない全部エクスペディアで。もちろん、設定していま sorted へ False.

としての始まり while ループのこのリストが全部エクスペディアで。のことです:として二つの要素は右の順に設定していま sorted に戻る False. sorted のままに 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.

いまからちょっとマイナーな課題をどのような役割が期待コードのさらなる効率化やすことはないですね。

• の for ループを使用した変数 element.技術的には、 element ではない素この番号を表すリストindex.また、この長さです。この場合、もう一時的な変数の名前のように、 i のための"インデックス".

  for i in range(0, length):
  

• の range コマンドでもう一つの引数の名前 stop).そのような場合、の一覧を取得します全ての整数を0にする引数です。

  for i in range(length):
  

• の Pythonのスタイルガイド を推奨して変数名には小文字をアンダースコア(_).これは非常に小nitpickちょっとスクリプトこのようなすることがあります。になれますかPythonコードによく似た.

  def bubble(bad_list):
  

• るスワップの価値観の二つの変数、書きして、そのタプル。右側が評価としてのタプル(例えば、 (badList[i+1], badList[i]) は (3, 5) しが割り当てられた、二つの変数を左側((badList[i], badList[i+1])).

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

けでは、なくてはならない、できます:

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

(取り出して、その印刷書を買うことができない人々がいるのです。)

Answer 2

目的のバブルソートするための 重 項目の各ラウンドを動かしながら、 軽量化 項目です。内側のループは、を比較すると、要素 んに対して繰り返し処理を実行する全体のリストを各.の ヘ 既に配置します。の 入れ替え 変数はエキストラで確認できまマークの登録がお済でない方は、整理回避の続き不要。

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

バージョン1、訂正:

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

Answer 3

これは、あなたが否定的な意味の変数名を使用する場合、あなたはそれらの値を反転する必要があり、何が起こるかです。

：次は、理解しやすいだろう

sorted = False
while not sorted:
    ...

一方、アルゴリズムの論理が少しオフになっています。次の2つの要素がループの中にスワップするかどうかをチェックする必要があります。ここで私はそれを書くだろう方法は次のとおりです。

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

Answer 4

ソートされていない変数の使用は間違っています。あなたは2つの要素をスワップしている場合は、あなたを伝える変数を持つようにしたいです。あなたはそれを行っている場合、あなたはあなたのループを終了することができ、そうでない場合は、再度ループする必要があります。あなたがここに持っているもの修正するには、ちょうどあなたの場合例本文に「偽=ソートされていない」を置きます。あなたの他のケースを取り外します。そして、あなたのforループの前に「ソートされていない=真を入れます。

Answer 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

Answer 6

#A非常に単純な関数、第2のアレイの問題空間を減少させることによって（明らかに）最適化することができます。しかし、同じ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 

Answer 7

あなたはそこにエラーのカップルを持っています。第一の長さであり、第二は、（McWafflestixにより述べたように）未分類の使用です。あなたは、おそらくも、あなたがそれを印刷するつもりなら、リストを返したいます：

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：そうだね、上記の地獄のようにバグがあります。いくつかのより多くの例を挙げてテストしていないための私の悪います。

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

Answer 8

私は新鮮な新鮮な初心者です、昨日のPythonについて読み始めました。 あなたの例に触発され、私は80-ネクタイスタイルで多分より多くのものを作成し、それにもかかわらず、それはちょっと作品

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)

Answer 9

この独自のアルゴリズムはまた、より小さい番号のリストを上げることで、正しくソートされます。のプログラムのニーズに戻る初れるための番号のままだった。

私は簡体字のコードでは今後、他のリスト番号にかかわらずリストの場が存在する場合においても、繰り返します。こちらのコード

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)

Answer 10

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

Answer 11

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

連想リスト= [54,26,93,17,77,31,44,55,20、-23、-34,16,11,11,11

印刷バブルソート（連想リスト）

Answer 12

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

Answer 13

シンプルな例：

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

これは単に（そのラウンドでは基本的に、すべてのソートされていない要素）を0から要素を取得し、その隣接要素と比較し、それがその隣接要素よりも大きい場合、スワップを行います。最後のラウンドでは、最後の要素がソートされ、すべての要素がソートされるまでのプロセスは、それなしで再び実行されます。

sortが真であるかどうかの条件のための必要はありません。

このアルゴリズムはスワップた場合にのみ考慮数字の位置をとり、その繰り返しの数字がそれに影響を与えないことに注意してください。

PS。私はこの質問が投稿されましたので、それは非常に長くなっているけど、私はこのアイデアを共有したいと思っています。

Answer 14

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

Answer 15

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 )

Answer 16

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

Answer 17

-怒りが提供する

回答とマーティン・コートは、無限ループの問題を修正しますが、私のコードは正常に動作しません（大きなリストについては、それが正しくソートすることはありません。）。私はunsorted変数を捨ててしまって、代わりにカウンターを使用します。

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)

誰もがコメントで私のコードを改善する方法上の任意のポインタを提供することができれば、

、それははるかに高く評価されるだろう。

Answer 18

これを試してみてください。

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)

Answer 19

私は私の解決策を共有したいと思います：

def bubble_sort(list_):
    for i in range(len(list_)):
        for j in range(i, len(list_)):
            if a[i] > a[j]:
                a[i], a[j] = a[j], a[i]
return list_

試験例：

a = [8,1,2,4,1,3,5,1,5,6,1,8]
bubble_sort(a)

結果：

[1, 1, 1, 1, 2, 3, 4, 5, 5, 6, 8, 8]

Answer 20

これは、9年後にあなたを助けるかもしれない場合は、

IDKの... その簡単なバブルソートプログラム

    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]

Answer 21

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 

Answer 22

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

Answer 23

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