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, 从大到小排序, 对相邻的两位进行比较