arr

=

[

7

,

4

,

3

,

67

,

34

,

1

,

8

]

.

def

bubble_sort

:

最近在學習Python，下面是我的一些筆記

冒泡排序

實現思路： 使用雙重for循環，內層變量為i， 外層為j，在內層循環中不斷的比較相鄰的兩個值(i, i+1)的大小，如果i+1的值大于i的值，交換兩者位置，每循環一次，外層的j增加1，等到j等于n-1的時候，結束循環

第一次看不懂很正常，不要灰心，下面是使用代碼的實現

arr =[7,4,3,67,34,1,8]defbubble_sort(arr):

n =len(arr)for j inrange(0, n -1):for i inrange(0, n -1- j):if arr[i]> arr[i +1]:

arr[i], arr[i +1]= arr[i +1], arr[i]

bubble_sort(arr)print(arr)# [1, 3, 4, 7, 8, 34, 67]

關鍵點其實在雙重for循環變量的配置，我們來分析一下

第一次循環： j = 0, i~n-2 range(0, n-1)

第二次循環： j = 1, i~n-3 range(0, n-1-1)

第三次循環： j = 2, i~n-4 range(0, n-1-1-1)

—> range(0, n-1-j)

理解這一點后，我們就可以換一種寫法來實現了

defbubble_sort2(arr):for j inrange(len(arr)-1,0,-1):# [n-1, n-2, ....2, 1]for i inrange(0, j):if arr[i]> arr[i +1]:

arr[i], arr[i +1]= arr[i +1], arr[i]

bubble_sort2(arr)print(arr)# [1, 3, 4, 7, 8, 34, 67]

優化

寫到這里我們發現，無論是第一種寫法還是第二種寫法，他的時間復雜度都是O(n ^ 2), 第二種寫法也僅僅停留在優化樣式的層面，并沒有帶來性能的提升，想象一下，如果我們輸入的本來就是一個有序序列，其實只需要一次循環就夠了，所以我們需要針對特殊情況進行優化

defbubble_sort3(arr):for j inrange(len(arr)-1,0,-1):

count =0for i inrange(0, j):if arr[i]> arr[i +1]:

arr[i], arr[i +1]= arr[i +1], arr[i]

count +=1if count ==0:return

bubble_sort3(arr)print(arr)# [1, 3, 4, 7, 8, 34, 67]

我們在循環中定義了一個變量count，如果第一次循環后count沒有變化，就說明輸入的是有序序列，這時我們直接return退出循環，這時候的時間復雜度為O(n)

擴展知識：冒泡排序還是一種穩定性的算法，如果序列中出現兩個相同的值的時候，無論選取最大值，還是最小值進行排序，最后兩個相同值的前后位置都是不變的。

python中怎樣實現冒泡排序

array = [1,18,3,7,2,4]

for i in range(len(array))[::1]:

for j in range(i):

if array[j] > array[j + 1]:

array[j], array[j + 1] = array[j + 1], array[j]

print array

必須再倒過來排一下，加個 [::1] 這個代碼才對

python冒泡排序方法

#-*-coding:utf-8-*-

#g:/python

#冒泡排序

#1.定義一個列表

number=[6665,666,323,124,4442,5,123,412,55]

#外循環控制冒泡排序的次數，n個數為n-1次

for i in range(0,len(number)-1):

#內循環控制每次排序對比的次數，n個數對比n-1次

for j in range(0,len(number)-1):

#進行對比，交換位置

if(number[j]>number[j+1]):

index=number[j+1]

number[j+1]=number[j]

number[j]=index

#輸出排序后的列表

print(number)

用Python實現從輸入若干個整數,直接輸入回車表示結...

用Python實現從輸入若干個整數,直接輸入回車表示結束,用冒泡法進行排序...

用Python實現從輸入若干個整數,直接輸入回車表示結束,用冒泡法進行排序

python 解決冒泡排序法 實在看不懂呀 誰能一行一行...

這個看起來簡單，卻并不好解釋。

首先你要明白xrange是什么，知道了xrange的用法，自然后不會再問”-1 -1 -1“這樣的問題了，

xrange返回的是一個生成器對象，其結果可以勉強理解為一個列表(range()返回的就是一個列表，但是兩者絕不相同，xrange()只有對其遍歷的時候才會生成具體的結果。)

xrange()的具體用法請自己百度！

以上例來說：

for j in xrange(len(numbers)-1,-1,-1):

j的遍歷結果為4,3,2,1,0

for i in xrange(j):

當j=4時，i的遍歷結果為0,1,2,3

...

然后只要你明白冒泡排序的原理，就能知道，

當j=4時通過i的遍歷對numbers的兩兩相鄰元素對比交換把最小的數字放到最前面

當j=3時......把第二小的元素放到第二的位置...

...

祝你成功！

python冒泡排序法求告知哪里錯了_(:з」∠)_

恩...Python小新人剛學到冒泡排序那里..回家試了一下不知道為什么就是不對求告知哪里錯了，還有最后的None請問是啥..怎么去掉謝謝！！...

恩...Python小新人剛學到冒泡排序那里..

回家試了一下不知道為什么就是不對 求告知哪里錯了，還有最后的None請問是啥..怎么去掉

謝謝！！



冒泡排序算法的運作如下：

1. 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。

2. 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。這步做完后，最后的元素會是最大的數。

3. 針對所有的元素重復以上的步驟，除了最后一個。

4. 持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

所以可以看出，你代碼僅僅比較了一次相鄰的兩個，而沒有繼續往后比較，輸出的第三行開始出現問題。至于那個None，因為你定義函數沒有返回值的原因。

我給你三個函數，你對比一下：

def?list_sort_new(list_in):

for?j?in?range(len(list_in)-1,?0?,-1):

for?i?in?range(0,?j):

if?list_in[i]>list_in[i+1]:

list_in[i],list_in[i+1]?=?list_in[i+1],list_in[i]

return?list_in

def?list_sort_old(list_in):

for?j?in?range(len(list_in)-1,?0?,-1):

for?i?in?range(0,?j):

if?list_in[i]>list_in[i+1]:

list_temp?=?list_in[i]

list_in[i]?=?list_in[i+1]

list_in[i+1]?=?list_temp

return?list_in

def?list_sort_test(list_in):

for?j?in?range(len(list_in)-1,?0?,-1):

for?i?in?range(0,?j):

if?list_in[i]>list_in[i+1]:

print?"before>>?"?+?str(list_in[i])

list_in[i]?=?list_in[i+1]

print?"after>>?"?+?str(list_in[i])

list_in[i+1]?=?list_in[i]

print?"and>?"?+?str(list_in[i+1])

return?list_in

list_test?=?[2,?1,?3,?44,?22,?53,?25,?26]

print?list_test

print?"*"*20

print(list_sort_test(list_test))

其中函數list_sort_new()和list_sort_old()都能實現你的目的，其中list_sort_new()中使用了指派運算， 就相當于c語言的i++。 list_sort_old()類似于你的想法，其中j的for實現了全部比較，而倒序減少了不必要的比較，list_sort_test()告訴了你，為什么需要一個變量來充當緩存。

住好運。。。。

python冒泡排序的測試函數，給個例子，謝謝

def?bubbleSort(myList):

#?首先獲取list的總長度,為之后的循環比較作準備

length?=?len(myList)

#?一共進行幾輪列表比較,一共是(length-1)輪

for?i?in?range(0,?length?-?1):

#?每一輪的比較,注意range的變化,這里需要進行length-1-長的比較,注意-i的意義(可以減少比較已經排好序的元素)

for?j?in?range(0,?length?-?1?-?i):

#?交換

if?myList[j]?>?myList[j?+?1]:

tmp?=?myList[j]

myList[j]?=?myList[j?+?1]

myList[j?+?1]?=?tmp

#?打印每一輪交換后的列表

for?item?in?myList:

print(item)

print("=============================")

print("Bubble?Sort:?")

myList?=?[2,0,1,8,0,3,0,2]

bubbleSort(myList)

python冒泡排序運行順序

(不知道有沒有人知道我想表達的問題，我說不清楚，解決了問題我采納回答)想知道圖中代碼運行順序。是1里面的代碼循環直到把fish_records里最大的數排在最后一位然后再運行2嗎？也就...

(不知道有沒有人知道我想表達的問題，我說不清楚，解決了問題我采納回答) 想知道圖中代碼運行順序。是1里面的代碼循環直到把fish_records里最大的數排在最后一位然后再運行2嗎？也就是［8,7,2,3,6,1,1,18］。。。為什么1里不是［8,18，7，2，3，6，1，1］再運行2 ?

展開



用python寫一個冒泡排序，讓用戶輸入一組整型數字...

同上...

同上

參考代碼如下：

#include

int main()

{

int a[10];//用來存數據

int i,j,temp;

for(i = 0; i < 10; i ++)//輸入10個數。

scanf("%d",&a[i]);

for (j = 0; j < 9; j++)//標準冒泡法排序

for (i = 0; i < 9- j; i++)

{

if(a[i] > a[i + 1])

{

temp = a[i];

a[i] = a[i + 1];

a[i + 1] = temp;

}

}

for(i = 0; i < 10; i ++)//輸出。

printf("%d,",&a[i]);

printf("\n");

return 0;

}

python 冒泡排序怎么寫不讓最大的兩個值相等

冒泡排序的時間復雜度是O(N^2)

冒泡排序的思想: 每次比較兩個相鄰的元素, 如果他們的順序錯誤就把他們交換位置

比如有五個數: 12, 35, 99, 18, 76, 從大到小排序, 對相鄰的兩位進行比較

總結

以上是生活随笔為你收集整理的python冒泡排序函数_python冒泡排序-Python,冒泡排序的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。