冒泡排序.docx
《冒泡排序.docx》由会员分享，可在线阅读，更多相关《冒泡排序.docx（16页珍藏版）》请在冰豆网上搜索。
冒泡排序
冒泡排序
百科名片
大泡在上，小泡在下——冒泡排序基本原理。
冒泡排序，是指计算机的一种排序方法，它的时间复杂度为O（n^2），虽然不及堆排序、快速排序的O（nlogn，底数为2），但是有两个优点：
1.“编程复杂度”很低，很容易写出代码；2.具有稳定性，这里的稳定性是指原序列中相同元素的相对顺序仍然保持到排序后的序列，而堆排序、快速排序均不具有稳定性。
不过，一路、二路归并排序、不平衡二叉树排序的速度均比冒泡排序快，且具有稳定性，但速度不及堆排序、快速排序。
冒泡排序是经过n-1趟子排序完成的，第i趟子排序从第1个数至第n-i个数，若第i个数比后一个数大（则升序，小则降序）则交换两数
目录
基本概念
1.产生
2.排序过程
3.算法示例
冒泡排序代码
1.AAuto
2.C语言
3.C++
4.PHP
5.Ruby
6.Java
7.VisualBasic
8.Pascal
9.C#
10.Python
11.JS
12.伪代码
13.改进
14.变种算法
性能分析
基本概念
1.产生
2.排序过程
3.算法示例
冒泡排序代码
1.AAuto
2.C语言
3.C++
4.PHP
5.Ruby
6.Java
7.VisualBasic
8.Pascal
9.C#
10.Python
11.JS
12.伪代码
13.改进
14.变种算法
性能分析
展开
编辑本段基本概念
冒泡排序（BubbleSort）的基本概念是：
依次比较相邻的两个数，将小数放在前面，大数放在后面。
即在第一趟：
首先比较第1个和第2个数，将小数放前，大数放后。
然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。
至此第一趟结束，将最大的数放到了最后。
在第二趟：
仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。
如此下去，重复以上过程，直至最终完成排序。
由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。
用二重循环实现，外循环变量设为i，内循环变量设为j。
外循环重复9次，内循环依次重复9，8，...，1次。
每次进行比较的两个元素都是与内循环j有关的，它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,...,9，对于每一个i,j的值依次为1,2,...10-i。
产生
在许多程序设计中，我们需要将一个数列进行排序，以方便统计，而冒泡排序一直由于其简洁的思想方法而倍受青睐。
排序过程
设想被排序的数组R［1..N］垂直竖立，将每个数据元素看作有重量的气泡，根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R，凡扫描到违反本原则的轻气泡，就使其向上"漂浮"，如此反复进行，直至最后任何两个气泡都是轻者在上，重者在下为止。
算法示例
4913131313131313
3849272727272727
6538493838383838
9765384949494949
7697654949494949
1376976565656565
2727769776767676
4949497697979797
ProcedureBubbleSort（VarR:
FileType）//从下往上扫描的起泡排序//
Begin
ForI:
=1ToN-1Do//做N-1趟排序//
begin
NoSwap:
=True;//置未排序的标志//
ForJ:
=N-1DownTo1Do//从底部往上扫描//
begin
IfR[J+1] begin
Temp:
=R[J+1];R[J+1:
=R[J];R[J]:
=Temp;
NoSwap:
=False
end;
end;
IfNoSwapThenReturn//本趟排序中未发生交换，则终止算法//
end
End;//BubbleSort//
该算法的时间复杂性为O（n^2）,算法为稳定的排序方
编辑本段冒泡排序代码
AAuto
bubble_sort=function（array）{
vartemp;
for（i=1;#array）{
//i前面的已经是最小的数，并排序好了
for（j=#array;i+1;-1）{
//挨个比较
if（array[j] //小的总是往前排
bubble=array[j]
array[j]=array[j-1];
array[j-1]=bubble;
}
}
}
}
io.print（"----------------"）
io.print（"冒泡排序（交换类换排序）"）
io.print（"----------------"）
array={2;46;5;17;1;2;3;99;12;56;66;21};
bubble_sort（array,1,#array）
//输出结果
for（i=1;#array;1）{
io.print（array[i]）
}
C语言
voidbubble_sort（intarray[],intn）
{
inti,j,flag,temp;
for（i=0;i {
flag=1;
for（j=0;j {
if（array[j]>array[j+1]）
{
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
flag=0;
}
}
if（flag==1）break;
printf（"%d",i）;
}
return;
}
C++
#include
#defineLEN9
usingnamespacestd;
intmain（）
{
intnArray[LEN];
for（inti=0;i cout<<"原始数据为：
"< for（inti=0;i cout< //开始冒泡
{
inttemp;
for（inti=LEN-1;i>0;i--）
for（intj=0;j {
if（nArray[j]>nArray[j+1]）
{
temp=nArray[j];
nArray[j]=nArray[j+1];
nArray[j+1]=temp;
}
}
}
//结束冒泡
cout<<"排序结果:
"< for（inti=0;i return0;
}
PHP
php
//冒泡排序（一维数组）
functionbubble_sort（$array）
{
$count=count（$array）;
if（$count<=0）returnfalse;
for（$i=0;$i<$count;$i++）
{
for（$j=$count-1;$j>$i;$j--）
{
if（$array[$j]<$array[$j-1]）
{
$tmp=$array[$j];
$array[$j]=$array[$j-1];
$array[$j-1]=$tmp;
}
}
}
return$array;
}
//使用实例
$_array=array（'5','8','5','6','9','3','2','4'）;
$_array=bubble_sort（$_array）;
print（$_array）;
?
>
Ruby
defbubble（arr）
（arr.length-1）.downto
（1）do|j|
a1=arr.dup
j.timesdo|i|
ifarr>arr[i+1]
arr,arr[i+1]=arr[i+1],arr
end
end
breakifa1==arr
end
arr
end
Java
//冒泡排序
publicclassBubbleSort{
publicstaticvoidsort（Comparable[]data）{
//数组长度
intlen=data.length;
for（inti=0;i //临时变量
Comparabletemp=null;
//交换标志,false表示未交换
booleanisExchanged=false;
for（intj=len-1;j>i;j--）{
//如果data[j]小于data[j-1],交换
if（data[j].compareTo（data[j-1]）<0）{
temp=data[j];
data[j]=data[j-1];
data[j-1]=temp;
//发生了交换,故将交换标志置为真
isExchanged=true;
}//endif
}//endfor
//本趟排序未发生交换,提前终止算法,提高效率
if（!
isExchanged）{
return;
}//endif
}//endfor
}//endsort
publicstaticvoidmain（String[]args）{
//在JDK1.5版本以上,基本数据类型可以自动装箱
//int,double等基本类型的包装类已实现了Comparable接口
Comparable[]c={4,9,23,1,45,27,5,2};
sort（c）;
for（Comparabledata:
c）{
System.out.println（data）;
}
}
}
VisualBasic
Subttttttttt（）
Dima,cAsVariant
DimiAsInteger,jAsInteger,tempAsInteger,bSwapAsBoolean
a=Array（17,45,12,80,50）
Forj=0ToUBound（a）-1
bSwap=False
Fori=0ToUBound（a）-1
If（a（i）>a（i+1））Then'若是递减,改为a（i） temp=a（i）
a（i）=a（i+1）
a（i+1）=temp
bSwap=True
EndIf
Next
IfbSwap=FalseThen
ExitFor
EndIf
Next
ForEachcIna
Debug.Printc;
Next
EndSub
Pascal
programname;
var
a:
array[1..N]of1..MAX;
temp,i,j:
integer;
begin
randomize;
fori:
=1toNdoa:
=1+random（MAX）;
writeln（'Arraybeforesorted:
'）;
fori:
=1toNdowrite（a,''）;
writeln;
fori:
=N-1downto1do
forj:
=1toido
ifa[j] begin
temp:
=a[j];
a[j]:
=a[j+1];
a[j+1]:
=temp
end;
writeln（'Arraysorted:
'）;
fori:
=1toNdowrite（a,''）;
writeln;
writeln（'Endsorted.'）;
readln;
end.
C#
publicvoidBubbleSort（int[]array）
{
intlength=array.Length;
for（inti=0;i<=length-1;i++）
{
for（intj=length-1;j>i;j--）
{
if（array[j] {
inttemp=array[j];
array[j]=array[j-1];
array[j-1]=temp;
}
}
}
}
Python
#BubbleSortusedpython3.1orpython2.x
defbubble（str）:
tmplist=list（str）
count=len（tmplist）
foriinrange（0,count-1）:
forjinrange（0,count-1）:
iftmplist[j]>tmplist[j+1]:
tmplist[j],tmplist[j+1]=tmplist[j+1],tmplist[j]
returntmplist
#useage:
str="zbac"
print（bubble（str））#['a','b','c','z']
number=[16,134,15,1]
print（bubble（number））#[1,15,16,134]
JS
varDataOne=newArray（5,6,7,8,3,1,2,-1,100）
varlen=DataOne.length
for（vari=0;i {
for（varj=0;j {
One=DataOne[j]
Two=DataOne[j+1]
if（One {
DataOne[j]=Two
DataOne[j+1]=One
}
}
}
varstr=""
for（varn=0;n {
str+=DataOne[n]+","
}
alert（str）
伪代码
BUBBLESORT（A）
fori<-1tolength[A]
doforj<-length[A]downtoi+1
doifA[j] thenexchangeA[j]<->A[j-1]
改进
假设需用冒泡排序将4、5、7、1、2、3这6个数排序。
在该列中，第三趟排序结束后，数组已排好序，但计算机此时并不知道，因此还需要进行一趟比较。
如果这一趟比较中未发生任何数据交换，则计算机知道已排序好，可以不再进行比较了。
因而第四趟比较需要进行，但第五趟比较则是不必要的。
为此，我们可以考虑程序的优化。
为了标志是否需要继续比较，声明一个布尔量flag，在进行每趟比较前将flag置true。
如果在比较中发生了数据交换，则将flag置为false，在一趟比较结束后，再判断flag，如果它仍为true（表明在该趟比较中未发生一次数据交换）则结束排序，否则进行下一趟比较。
变种算法
一个叫做鸡尾酒排序（也称双向冒泡排序）的算法，和冒泡排序的“编程复杂度”一样，但对随机序列排序性能稍高于普通冒泡排序，但是因为是双向冒泡，每次循环都双向检查，极端环境下会出现额外的比较，导致算法性能的退化，比如“4、5、7、1、2、3”这个序列就会出现退化
编辑本段性能分析
若记录序列的初始状态为"正序"，则冒泡排序过程只需进行一趟排序，在排序过程中只需进行n-1次比较，且不移动记录；反之，若记录序列的初始状态为"逆序"，则需进行n（n-1）/2次比较和记录移动。
因此冒泡排序总的时间复杂度为O（n*n）。
词条图册更多图册
扩展阅读：
∙1
http:
//www.zjyz.org/jiaoshi/jszy/Exg/competition/algorithm/sort2.htm
∙2
∙3
∙4
http:
//ruby-
升级会员 