blocks|key|1335851|text|这就是当你使用负意义的变量名时会发生的事情，你需要反转它们的值。下面的内容会更容易理解：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1335852|sorted+=+False
while+not+sorted:
++++...|code-block|syntax|javascript|1335853|另一方面，算法的逻辑有点离谱。您需要检查在for循环期间是否交换了两个元素。下面是我将如何编写它：|1335854|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+%2B+1]:
+++++++++++++++++hold+=+values[element+%2B+1]
+++++++++++++++++values[element+%2B+1]+=+values[element]
+++++++++++++++++values[element]+=+hold
+++++++++++++++++sorted+=+False
++++return+values|1335855|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This is what happens when you use variable name of negative meaning, you need to invert their values. The following would be easier to understand:

<pre><code>sorted = False
while not sorted:
 ...
</code></pre>

On the other hand, the logic of the algorithm is a little bit off. You need to check whether two elements swapped during the for loop. Here's how I would write it:

<pre><code>def bubble(values):
 length = len(values) - 1
 sorted = False
 while not sorted:
 sorted = True
 for element in range(0,length):
 if values[element] &gt; values[element + 1]:
 hold = values[element + 1]
 values[element + 1] = values[element]
 values[element] = hold
 sorted = False
 return values
</code></pre>

blocks|key|1551430|text|您使用未排序的变量是错误的；您希望有一个变量来告诉您是否交换了两个元素；如果您已经交换了两个元素，则可以退出循环，否则，您需要再次循环。要解决这里的问题，只需将"unsorted+=+false“放入if+case的主体中；删除else+case；并将"unsorted+=+true”放在for循环之前。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1551431|entityMap^0|41|3|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Your use of the Unsorted variable is wrong; you want to have a variable that tells you if you have swapped two elements; if you have done that, you can exit your loop, otherwise, you need to loop again. To fix what you've got here, just put the "unsorted = false" in the body of your if case; remove your else case; and put "unsorted = true before your <code>for</code> loop.

blocks|key|1551520|text|这里有几个错误。第一个是长度，第二个是使用unsorted+(如McWafflestix所述)。如果要打印列表，可能还需要返回该列表：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1551521|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+%2B+1]:
++++++++++++++++hold+=+badList[element+%2B+1]
++++++++++++++++badList[element+%2B+1]+=+badList[element]
++++++++++++++++badList[element]+=+hold
++++++++++++++++print+badList
++++++++++++++++unsorted+=+True

++++return+badList

print+bubble(mylist)|code-block|syntax|javascript|1551522|埃塔:你说得对，上面的错误简直就是地狱。我的缺点是没有通过更多的例子进行测试。|1551523|def+bubble2(badList):
++++swapped+=+True
++++length+=+len(badList)+-+2

++++while+swapped:
++++++++swapped+=+False
++++++++for+i+in+range(0,+length):
++++++++++++if+badList[i]+>+badList[i+%2B+1]:

++++++++++++++++#+swap
++++++++++++++++hold+=+badList[i+%2B+1]
++++++++++++++++badList[i+%2B+1]+=+badList[i]
++++++++++++++++badList[i]+=+hold

++++++++++++++++swapped+=+True

++++return+badList|1551524|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You've got a couple of errors in there. The first is in length, and the second is in your use of unsorted (as stated by McWafflestix). You probably also want to return the list if you're going to print it:

<pre><code>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] &gt; badList[element + 1]:
 hold = badList[element + 1]
 badList[element + 1] = badList[element]
 badList[element] = hold
 print badList
 unsorted = True

 return badList

print bubble(mylist)
</code></pre>

eta: You're right, the above is buggy as hell. My bad for not testing through some more examples.

<pre><code>def bubble2(badList):
 swapped = True
 length = len(badList) - 2

 while swapped:
 swapped = False
 for i in range(0, length):
 if badList[i] &gt; badList[i + 1]:

 # swap
 hold = badList[i + 1]
 badList[i + 1] = badList[i]
 badList[i] = hold

 swapped = True

 return badList
</code></pre>

blocks|key|1336040|text|-fury和Martin+Cote提供的答案修复了无限循环的问题，但我的代码仍然无法正常工作(对于更大的列表，它将无法正确排序。)我最终放弃了unsorted变量，转而使用计数器。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1336041|def+bubble(badList):
++++length+=+len(badList)+-+1
++++n+=+0
++++while+n+<+len(badList):
++++++++for+element+in+range(0,length):
++++++++++++if+badList[element]+>+badList[element+%2B+1]:
++++++++++++++++hold+=+badList[element+%2B+1]
++++++++++++++++badList[element+%2B+1]+=+badList[element]
++++++++++++++++badList[element]+=+hold
++++++++++++++++n+=+0
++++++++++++else:
++++++++++++++++n+%2B=+1
++++return+badList

if+__name__+==+'__main__':
++++mylist+=+[90,+10,+2,+76,+17,+66,+57,+23,+57,+99]
++++print+bubble(mylist)|code-block|syntax|javascript|1336042|如果有人能在评论中提供任何关于如何改进我的代码的建议，我将不胜感激。|1336043|entityMap^0|1Z|8|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

Answers provided by the-fury and Martin Cote fixed the problem of the infinite loop, but my code would still not work correctly (for a larger list, it would not sort correctly.). I ended up ditching the <code>unsorted</code> variable and used a counter instead.

<pre><code>def bubble(badList):
 length = len(badList) - 1
 n = 0
 while n &lt; len(badList):
 for element in range(0,length):
 if badList[element] &gt; 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)
</code></pre>

If anyone could provide any pointers on how to improve my code in the comments, it would be much appreciated.

blocks|key|1336054|text|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+%2B+1]:
+++++++++++++++l[index],+l[index+%2B+1]+=+l[index+%2B+1],+l[index]
++++return+l|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1336055|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def bubble_sort(l):
 for passes_left in range(len(l)-1, 0, -1):
 for index in range(passes_left):
 if l[index] &lt; l[index + 1]:
 l[index], l[index + 1] = l[index + 1], l[index]
 return l
</code></pre>

blocks|key|1551652|text|#一个非常简单的函数，可以通过减少第二个数组的问题空间来优化(显然)。但O(n%5E2)复杂度相同。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1551653|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+|code-block|syntax|javascript|1551654|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

#A very simple function, can be optimized (obviously) by decreasing the problem space of the 2nd array. But same O(n^2) complexity.

<pre><code>def bubble(arr):
 l = len(arr) 
 for a in range(l):
 for b in range(l-1):
 if (arr[a] &lt; arr[b]):
 arr[a], arr[b] = arr[b], arr[a]
 return arr 
</code></pre>

blocks|key|1336158|text|我是一个新鲜的初学者，昨天开始阅读有关Python的内容。受你的例子的启发，我创建了一些可能更符合80年代风格的东西，但尽管如此，它还是挺有效的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1336159|lista1+=+[12,+5,+13,+8,+9,+65]

i=0
while+i+<+len(lista1)-1:
++++if+lista1[i]+>+lista1[i%2B1]:
++++++++x+=+lista1[i]
++++++++lista1[i]+=+lista1[i%2B1]
++++++++lista1[i%2B1]+=+x
++++++++i=0
++++++++continue
++++else:
++++++++i%2B=1

print(lista1)|code-block|syntax|javascript|1336160|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I am a fresh fresh beginner, started to read about Python yesterday.
Inspired by your example I created something maybe more in the 80-ties style, but nevertheless it kinda works

<pre><code>lista1 = [12, 5, 13, 8, 9, 65]

i=0
while i &lt; len(lista1)-1:
 if lista1[i] &gt; lista1[i+1]:
 x = lista1[i]
 lista1[i] = lista1[i+1]
 lista1[i+1] = x
 i=0
 continue
 else:
 i+=1

print(lista1)
</code></pre>

blocks|key|1336198|text|原始算法的问题是，如果列表中有一个更小的数字，它不会将其带到正确的排序位置。程序每次都需要回到开头，以确保数字始终排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1336199|我简化了代码，现在它将适用于任何数字列表，无论该列表是什么，即使有重复的数字。下面是代码|1336200|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+%2B+1]:
++++++++++++hold+=+badList[element+%2B+1]
++++++++++++badList[element+%2B+1]+=+badList[element]
++++++++++++badList[element]+=+hold
++++++++++++element+=+0
++++++++++++print+badList
++++++++else:
++++++++++++element+=+element+%2B+1

print+bubble(mylist)|code-block|syntax|javascript|1336201|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The problem with the original algorithm is that if you had a lower number further in the list, it would not bring it to the correct sorted position. The program needs to go back the the beginning each time to ensure that the numbers sort all the way through.

I simplified the code and it will now work for any list of numbers regardless of the list and even if there are repeating numbers. Here's the code

<pre><code>mylist = [9, 8, 5, 4, 12, 1, 7, 5, 2]
print mylist

def bubble(badList):
 length = len(badList) - 1
 element = 0
 while element &lt; length:
 if badList[element] &gt; 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)
</code></pre>

blocks|key|1336222|text|def+bubble_sort(l):
++++exchanged+=+True
++++iteration+=+0
++++n+=+len(l)

++++while(exchanged):
++++++++iteration+%2B=+1
++++++++exchanged+=+False

++++++++#+Move+the+largest+element+to+the+end+of+the+list
++++++++for+i+in+range(n-1):
++++++++++++if+l[i]+>+l[i%2B1]:
++++++++++++++++exchanged+=+True
++++++++++++++++l[i],+l[i%2B1]+=+l[i%2B1],+l[i]
++++++++n+-=+1+++#+Largest+element+already+towards+the+end

++++print+'Iterations:+%25s'+%25(iteration)
++++return+l|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1336223|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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] &gt; 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
</code></pre>

blocks|key|1551835|text|def+bubbleSort(alist):
if+len(alist)+<=+1:
++++return+alist
for+i+in+range(0,len(alist)):
+++print+"i+is+:%25d",i
+++for+j+in+range(0,i):
++++++print+"j+is:%25d",j
++++++print+"alist[i]+is+:%25d,+alist[j]+is+:%25d"%25(alist[i],alist[j])
++++++if+alist[i]+>+alist[j]:
+++++++++alist[i],alist[j]+=+alist[j],alist[i]
return+alist|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1551836|列表=+54,26,93,17,77,31,44,55,20，-23，-34,16,11,11,11|unstyled|1551837|打印bubbleSort(列表)|1551838|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>def bubbleSort(alist):
if len(alist) &lt;= 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] &gt; alist[j]:
 alist[i],alist[j] = alist[j],alist[i]
return alist
</code></pre>

alist = [54,26,93,17,77,31,44,55,20,-23,-34,16,11,11,11]

print bubbleSort(alist)

blocks|key|1336290|text|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|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1336291|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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] &gt; a[key]:
 sorted = False
 t = a[key-1]; a[key-1] = a[key]; a[key] = t;
 print a
</code></pre>

blocks|key|1336360|text|一个更简单的例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1336361|a+=+len(alist)-1
while+a+>+0:
++++for+b+in+range(0,a):
++++++++#compare+with+the+adjacent+element
++++++++if+alist[b]>=alist[b%2B1]:
++++++++++++#swap+both+elements
++++++++++++alist[b],+alist[b%2B1]+=+alist[b%2B1],+alist[b]
++++a-=1|code-block|syntax|javascript|1336362|这只是将元素从0到a(基本上是该轮中所有未排序的元素)，并将其与其相邻元素进行比较，如果它大于其相邻元素，则进行交换。在循环结束时，最后一个元素被排序，该过程在没有它的情况下再次运行，直到所有元素都排序完毕。|1336363|不需要一个条件来判断sort是否为真。|offset|length|style|CODE|1336364|请注意，此算法仅在交换时考虑数字的位置，因此重复的数字不会影响它。|1336365|PS。我知道这个问题已经发布很久了，但我只想分享这个想法。|1336366|entityMap^0|0|0|0|A|4|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|X|8|@$K|Y|L|Z|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

A simpler example:

<pre><code>a = len(alist)-1
while a &gt; 0:
 for b in range(0,a):
 #compare with the adjacent element
 if alist[b]&gt;=alist[b+1]:
 #swap both elements
 alist[b], alist[b+1] = alist[b+1], alist[b]
 a-=1
</code></pre>

This simply takes the elements from 0 to a(basically, all the unsorted elements in that round) and compares it with its adjacent element, and making a swap if it is greater than its adjacent element. At the end the round, the last element is sorted, and the process runs again without it, until all elements have been sorted.

There is no need for a condition whether <code>sort</code> is true or not.

Note that this algorithm takes into consideration the position of the numbers only when swapping, so repeated numbers will not affect it.

PS. I know it has been very long since this question was posted, but I just wanted to share this idea.

blocks|key|1336396|text|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%2B1]:
++++++++++++++++tmp+=+li[ele%2B1]
++++++++++++++++li[ele%2B1]+=+li+[ele]
++++++++++++++++li[ele]+=+tmp
++++return+li|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1336397|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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] &gt; li[ele+1]:
 tmp = li[ele+1]
 li[ele+1] = li [ele]
 li[ele] = tmp
 return li
</code></pre>

blocks|key|1551987|text|def+bubbleSort+(+arr+):
++++swapped+=+True+
++++length+=+len+(+arr+)
++++j+=+0

++++while+swapped:
++++++++swapped+=+False
++++++++j+%2B=+1+
++++++++for+i+in+range+(+length++-+j+):
++++++++++++if+arr+[+i+]+>+arr+[+i+%2B+1+]:
++++++++++++++++#+swap
++++++++++++++++tmp+=+arr+[+i+]
++++++++++++++++arr+[+i+]+=+arr+[+i+%2B+1]
++++++++++++++++arr+[+i+%2B+1+]+=+tmp+

++++++++++++++++swapped+=+True

if+__name__+==+'__main__':
++++#+test+list
++++a+=+[+67,+45,+39,+-1,+-5,+-44+];

++++print+(+a+)
++++bubbleSort+(+a+)
++++print+(+a+)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1551988|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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 ] &gt; 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 )
</code></pre>

blocks|key|1552009|text|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):|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1552010|+++++++++`#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`|code-block|syntax|javascript|1552011|entityMap^0|0|6N|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

<code>
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] &lt; a[j]:
 swap(j, i)
 #find the max index and swap
 if a[i] &gt; a[len(a) - j - 1]:
 swap(len(a) - j - 1, i)
 return a
</code>

blocks|key|1552032|text|def+bubblesort(array):
++++for+i+in+range(len(array)-1):
++++++++for+j+in+range(len(array)-1-i):
++++++++++++if+array[j]+>+array[j%2B1]:
++++++++++++++++array[j],+array[j%2B1]+=+array[j%2B1],+array[j]
++++return(array)

print(bubblesort([3,1,6,2,5,4]))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1552033|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def bubblesort(array):
 for i in range(len(array)-1):
 for j in range(len(array)-1-i):
 if array[j] &gt; array[j+1]:
 array[j], array[j+1] = array[j+1], array[j]
 return(array)

print(bubblesort([3,1,6,2,5,4]))
</code></pre>

blocks|key|1552055|text|尝尝这个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1552056|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%2B1]:
+++++++++++t+=+val[x]
+++++++++++val[x]+=+val[x%2B1]
+++++++++++val[x%2B1]+=+t

print(val)|code-block|syntax|javascript|1552057|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try this

<pre><code>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]&gt;val[x+1]:
 t = val[x]
 val[x] = val[x+1]
 val[x+1] = t

print(val)
</code></pre>

blocks|key|1336484|text|idk如果9年后这对你有帮助...这是一个简单的冒泡排序程序|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1336485|++++l=[1,6,3,7,5,9,8,2,4,10]

++++for+i+in+range(1,len(l)):
++++++++for+j+in+range+(i%2B1,len(l)):
++++++++++++if+l[i]>l[j]:
++++++++++++++++l[i],l[j]=l[j],l[i]|code-block|syntax|javascript|1336486|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

idk if this might help you after 9 years...
its a simple bubble sort program

<pre><code> 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]&gt;l[j]:
 l[i],l[j]=l[j],l[i]
</code></pre>

blocks|key|1552096|text|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%2B1]:
++++++++++++++++++++arr[j],arr[j%2B1]+=+arr[j%2B1],arr[j]

++++++++return+arr
++++++++break
++++else:
++++++++if+arr[0]+>+arr[1]:
++++++++++++arr[0],arr[1]+=+arr[1],arr[0]
++++++++return+arr+|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1552097|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def merge_bubble(arr):
 k = len(arr)
 while k&gt;2:
 for i in range(0,k-1):
 for j in range(0,k-1):
 if arr[j] &gt; arr[j+1]:
 arr[j],arr[j+1] = arr[j+1],arr[j]

 return arr
 break
 else:
 if arr[0] &gt; arr[1]:
 arr[0],arr[1] = arr[1],arr[0]
 return arr 
</code></pre>

blocks|key|1336517|text|def+bubble_sort(l):
++++for+i+in+range(len(l)+-1):
++++++++for+j+in+range(len(l)-i-1):
++++++++++++if+l[j]+>+l[j%2B1]:
++++++++++++++++l[j],l[j%2B1]+=+l[j%2B1],+l[j]
++++return+l|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1336518|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def bubble_sort(l):
 for i in range(len(l) -1):
 for j in range(len(l)-i-1):
 if l[j] &gt; l[j+1]:
 l[j],l[j+1] = l[j+1], l[j]
 return l
</code></pre>

blocks|key|1336531|text|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)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1336532|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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] &gt; arr[j]):
 arr[i], arr[j] = arr[j], arr[i]

 print (arr)
</code></pre>

blocks|key|1552152|text|如果有人对使用列表理解的更短的实现感兴趣：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1552153|def+bubble_sort(lst:+list)+->+None:
++++[swap_items(lst,+i,+i%2B1)+for+left+in+range(len(lst)-1,+0,+-1)+for+i+in+range(left)+if+lst[i]+>+lst[i%2B1]]


def+swap_items(lst:+list,+pos1:+int,+pos2:+int)+->+None:
++++lst[pos1],+lst[pos2]+=+lst[pos2],+lst[pos1]|code-block|syntax|javascript|1552154|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If anyone is interested in a shorter implementation using a list comprehension:

<pre><code>def bubble_sort(lst: list) -&gt; None:
 [swap_items(lst, i, i+1) for left in range(len(lst)-1, 0, -1) for i in range(left) if lst[i] &gt; lst[i+1]]


def swap_items(lst: list, pos1: int, pos2: int) -&gt; None:
 lst[pos1], lst[pos2] = lst[pos2], lst[pos1]
</code></pre>

blocks|key|1552229|text|下面是没有for循环的冒泡排序的不同变体。基本上，您是在考虑array的lastIndex，然后慢慢地对它进行decrementing，直到它成为数组的第一个索引。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1552230|algorithm将继续像这样在数组中移动，直到完成整个过程而没有发生任何swaps。|1552231|当涉及到性能时，泡泡是排序基本上是Quadratic+Time:+O(n²)。|1552232|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+%2B+1]):
++++++++self.swap(count)++
++++++count+=+count+%2B+1;

++++++if(count+==+lastIndex):
++++++++count+=+0;
++++++++lastIndex+=+lastIndex+-+1;+++

++def+swap(self,+count):
++++temp+=+self.arr[count];
++++self.arr[count]+=+self.arr[count+%2B+1];
++++self.arr[count+%2B+1]+=+temp;
++++
arr+=+[9,+1,+5,+3,+8,+2]
p1+=+BubbleSort(arr)

print(p1.bubbleSort())|code-block|syntax|javascript|1552233|entityMap^0|5|3|U|5|10|9|1J|C|0|0|9|11|5|0|H|L|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|17|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|P|$]]

Here is a different variation of bubble sort without <code>for</code> loop. Basically you are considering the <code>lastIndex</code> of the <code>array</code> and slowly <code>decrementing</code> it until it first index of the array.
The <code>algorithm</code> will continue to move through the array like this until an entire pass is made without any <code>swaps</code> occurring.
The bubble is sort is basically <code>Quadratic Time: O(n²)</code> when it comes to performance.
<pre><code>class BubbleSort: 
 def __init__(self, arr):
 self.arr = arr;

 def bubbleSort(self):
 count = 0;
 lastIndex = len(self.arr) - 1;
 
 while(count &lt; lastIndex):
 if(self.arr[count] &gt; 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())
</code></pre>

blocks|key|1336651|text|def+bubble_sorted(arr:list):
++++while+True:
++++++++for+i+in+range(0,len(arr)-1):
++++++++++++count+=+0
++++++++++++if+arr[i]+>+arr[i%2B1]:
++++++++++++++++count+%2B=+1
++++++++++++++++arr[i],+arr[i%2B1]+=+arr[i%2B1],+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]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1336652|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def bubble_sorted(arr:list):
 while True:
 for i in range(0,len(arr)-1):
 count = 0
 if arr[i] &gt; 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]
</code></pre>

In class we are doing sorting algorithms and, although I understand them fine when talking about them and writing pseudocode, I am having problems writing actual code for them.

This is my attempt in Python:

<pre><code>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] &gt; badList[element + 1]:
 hold = badList[element + 1]
 badList[element + 1] = badList[element]
 badList[element] = hold
 print badList
 else:
 unsorted = True

print bubble(mylist)
</code></pre>

Now, this (as far as I can tell) sorts correctly, but once it finishes it just loops indefinitely.

How can this code be fixed so the function finishes properly and correctly sorts a list of any (reasonable) size?

P.S. I know I should not really have prints in a function and I should have a return, but I just have not done that yet as my code does not really work yet.

Bubble Sort Homework

Python

在课堂上，我们正在做排序算法，尽管我在谈论它们和编写伪代码时很好地理解了它们，但我在为它们编写实际代码时遇到了问题。这是我在Python中的尝试：mylist = [12, 5, 13, 8, 9, 65]def bubble(badList):    length = len(badList) - 1    unso...

问冒泡排序作业
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问冒泡排序作业EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问冒泡排序作业
EN