python冒泡

❶ python冒泡排序運行順序

不是的，1是將第一個數逐個於它後面的數進行比較，比如i=1，就是18。這個就是所謂的冒泡演算法。

❷ python使用冒泡排序

冒泡排序（Bubble Sort）也是一種簡單直觀的排序演算法。它重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越小的元素會經由交換慢慢"浮"到數列的頂端。
def bubbleSort(arr):
n = len(arr)

# 遍歷所有數組元素
for i in range(n):

# Last i elements are already in place
for j in range(0, n-i-1):

if arr[j] > arr[j+1] :
arr[j], arr[j+1] = arr[j+1], arr[j]

arr = [64, 34, 25, 12, 22, 11, 90]

bubbleSort(arr)

print ("排序後的數組:")
for i in range(len(arr)):
print ("%d" %arr[i])

❸ python中冒泡比較排序，代碼怎麼寫

參考代碼如下：
#include <stdio.h>
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冒泡排序法的問題

選A，想了解清楚，就找找冒泡排序的演算法。

❺ python寫冒泡排序

冒泡排序（Bubble Sort），是一種計算機科學領域的較簡單的排序演算法。
它重復地走訪過要排序的元素列，依次比較兩個相鄰的元素，如果順序（如從大到小、首字母從Z到A）錯誤就把他們交換過來。走訪元素的工作是重復地進行直到沒有相鄰元素需要交換，也就是說該元素列已經排序完成。
這個演算法的名字由來是因為越小的元素會經由交換慢慢「浮」到數列的頂端（升序或降序排列），就如同碳酸飲料中二氧化碳的氣泡最終會上浮到頂端一樣，故名「冒泡排序」。
中文名
冒泡排序
外文名
Bubble Sort
所屬學科
計算機科學
時間復雜度
O（n2）
演算法穩定性
穩定排序演算法
快速
導航
演算法分析演算法描述優化演算法比較
演算法原理
冒泡排序演算法的原理如下：[1]
比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。[1]
對每一對相鄰元素做同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。[1]
針對所有的元素重復以上的步驟，除了最後一個。[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 冒泡排序

def maopao(list1):
n = len(list1)
for i in range(n-1):
for j in range(i+1,n):
if list1[i]>list1[j]: #通過交換讓最小的在最前面
list1[i],list1[j]=list1[j],list1[i]
if __name__=='__main__':
list1=[1,5,3,2]
maopao(list1)
print (list1)

❽ 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冒泡排序法求告知哪裡錯了_(:з」∠)_

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

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

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

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

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

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

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

deflist_sort_new(list_in):
forjinrange(len(list_in)-1,0,-1):
	foriinrange(0,j):
	iflist_in[i]>list_in[i+1]:
	list_in[i],list_in[i+1]=list_in[i+1],list_in[i]
returnlist_in

deflist_sort_old(list_in):
forjinrange(len(list_in)-1,0,-1):
foriinrange(0,j):
	iflist_in[i]>list_in[i+1]:
		list_temp=list_in[i]
		list_in[i]=list_in[i+1]
		list_in[i+1]=list_temp
returnlist_in

deflist_sort_test(list_in):
forjinrange(len(list_in)-1,0,-1):
	foriinrange(0,j):
	iflist_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])
returnlist_in


list_test=[2,1,3,44,22,53,25,26]
printlist_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()告訴了你，為什麼需要一個變數來充當緩存。

住好運。。。。