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