冒泡排序

冒泡排序

编辑

 
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名。
由于冒泡排序简洁的特点，它通常被用来对于计算机程序设计入门的学生介绍算法的概念。
 

1算法原理编辑

冒泡排序算法的运作如下：（从后往前）
  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
  3. 针对所有的元素重复以上的步骤，除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。[1]

2算法分析编辑

时间复杂度

若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数
 和记录移动次数
 均达到最小值：
 ，
 。
所以，冒泡排序最好的时间复杂度为
 。
　　若初始文件是反序的，需要进行
 趟排序。每趟排序要进行
 次关键字的比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：
冒泡排序的最坏时间复杂度为
 。
综上，因此冒泡排序总的平均时间复杂度为
 。

算法稳定性

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

算法描述

RUBY

1
2
3
4
5
6
7
8
9
defbubbleSort(array)
returnarrayifarray.size<2
(array.size-2).downto(0)do|i|
(0..i).eachdo|j|
array[j],array[j+1]=array[j+1],array[j]ifarray[j]>=array[j+1]
end
end
returnarray
end

PHP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
functionbubbleSort($numbers){
$cnt=count($numbers);
for($i=0;$i<$cnt-1;$i++){//循环比较
for($j=$i+1;$j<$cnt;$j++){
if($numbers[$j]<$numbers[$i]){//执行交换
$temp=$numbers[$i];
$numbers[$i]=$numbers[$j];
$numbers[$j]=$temp;
}
}
}
return$numbers;
}
 
$num=array(20,40,60,80,30,70,90,10,50,0);
var_dump(bubbleSort($num));
//输出结果如下：
//array(10){[0]=>int(0)[1]=>int(10)[2]=>int(20)[3]=>int(30)[4]=>int(40)[5]=>int(50)[6]=>int(60)[7]=>int(70)[8]=>int(80)[9]=>int(90)}

C#语言

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
冒泡算法C#
namespace数组排序
{
classProgram
{
staticvoidMain(string[]args)
{
inttemp=0;
int[]arr={23,44,66,76,98,11,3,9,7};
#region该段与排序无关
Console.WriteLine("排序前的数组：");
foreach(intiteminarr)
{
Console.Write(item+"");
}
Console.WriteLine();
#endregion
for(inti=0;i<arr.Length-1;i++)
{
#region将大的数字移到数组的arr.Length-1-i
for(intj=0;j<arr.Length-1-i;j++)
{
if(arr[j]>arr[j+1])
{
temp=arr[j+1];
arr[j+1]=arr[j];
arr[j]=temp;
}
}
#endregion
}
Console.WriteLine("排序后的数组：");
foreach(intiteminarr)
{
Console.Write(item+"");
}
Console.WriteLine();
Console.ReadKey();
}
}
}

Erlang

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
bubble_sort(L)->
bubble_sort(L,length(L)).
 
bubble_sort(L,0)->
L;
bubble_sort(L,N)->
bubble_sort(do_bubble_sort(L),N-1).
 
do_bubble_sort([A])->
[A];
do_bubble_sort([A,B|R])->
caseA<Bof
true->[A|do_bubble_sort([B|R])];
false->[B|do_bubble_sort([A|R])]
end.

C语言

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include<stdio.h>
#defineSIZE8
 
voidbubble_sort(inta[],intn);
 
voidbubble_sort(inta[],intn)//n为数组a的元素个数
{
    inti,j,temp;
    for(j=0;j<n-1;j++)
        for(i=0;i<n-1-j;i++)
        {
            if(a[i]>a[i+1])//数组元素大小按升序排列
            {
                temp=a[i];
                a[i]=a[i+1];
                a[i+1]=temp;
            }
        }
}
intmain()
{
    intnumber[SIZE]={95,45,15,78,84,51,24,12};
    inti;
    bubble_sort(number,SIZE);
    for(i=0;i<SIZE;i++)
    {
        printf("%d",number[i]);
    }
    printf("\n");
}

JAVA

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
publicclassBubbleSort
{
publicvoidsort(int[]a)
{
inttemp=0;
for(inti=a.length-1;i>0;--i)
{
for(intj=0;j<i;++j)
{
if(a[j+1]<a[j])
{
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
}
}

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
functionbubbleSort(arr)
{vari=arr.length,j;
vartempExchangVal;
while(i>0)
{
for(j=0;j<i-1;j++)
{
if(arr[j]>arr[j+1])
{
tempExchangVal=arr[j];
arr[j]=arr[j+1];
arr[j+1]=tempExchangVal;
}
}
i--;
}
returnarr;
}vararr=[3,2,4,9,1,5,7,6,8];
vararrSorted=bubbleSort(arr);
console.log(arrSorted);
alert(arrSorted);
控制台将输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]
并且弹窗；

易语言

数组 = { 233, 1,5, 5, 6, 8, 7, 9, 41, 62, 2, 1, 3, 0 }
　　c = 1
　　b = 取数组成员数 (数组)
　　.判断循环首 (c >0)
　　c = 0
　　.变量循环首 (1, b － 1, 1, d)
　　.如果真 (数组 [d] > 数组 [d + 1]) ' 此处用于，对两个数据进行对比，可以修改成，拼音，数字大小，文本长度，等等
　　e = 数组 [d]
　　数组 [d] = 数组 [d + 1]
　　数组 [d + 1] = e
　　b = d
　　c = c + 1
　　.如果真结束
　　.变量循环尾 ()
　　.判断循环尾 ()

BASIC语言

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Submaopao()
 
Dimaa=Array(233,10086,31,15,213,5201314,427)
 
DimiAsInteger,jAsInteger
 
Fori=UBound(a)-1To0Step-1
 
Forj=0Toi
Ifa(j)>a(j+1)Thena(j)=a(j)+a(j+1):a(j+1)=a(j)-a(j+1):a(j)=a(j)-a(j+1)'交换变量数值
EndIf
Nextj
Nexti
Fori=0ToUBound(a)
Printa(i)
Nexti
EndSub

Objective-C

(void)bubbleSort:(NSMutableArray *)array{ int i, y; BOOL bFinish = YES; for (i = 1; i<= [array count] && bFinish; i++) { bFinish = NO; for (y = (int)[array count]-1; y>=i; y--) { if ([[array objectAtIndex:y] intValue] < [[array objectAtIndex:y-1] intValue]) { [array exchangeObjectAtIndex:y-1 withObjectAtIndex:y]; bFinish = YES; } } }}Pythonalist = [1,12,2,4,51,66,45,25,96,78,55,23] def bubbleSort(aList): aLen = len(aList) for key in xrange(aLen-1): for x in xrange(aLen - key -1): if aList[x] > aList[x+1]: aList[x], aList[x+1] = aList[x+1], aList[x] print(alist)bubbleSort(alist)print(alist)

Go语言

package mainimport ("fmt")const (LENGTH=8){ func main() { var tmp intnumber:=[]int {95, 45, 15, 78, 84, 51, 24, 12} for i := 0; i < LENGTH; i++ { for j := LENGTH-1; j >i; j-- { if (number[j]<number[j-1]) { tmp=number[j-1] number[j-1]=number[j] number[j]=tmp } } } for i := 0; i < LENGTH; i++ { fmt.Printf("%d ", number[i]) } fmt.Printf("\n"); }}

GO语言2

Gofunc BubbleSort(values[] int) { flag := true vLen := len(values) for i := 0; i < vLen-1; i++ { flag = true for j := 0; j < vLen-i-1; j++ { if values[j] > values[j+1] { values[j], values[j+1] = values[j+1], values[j] flag = false //continue } } if flag { break } }}

Perl

#! /usr/bin/perl -w use strict; my @list = (1,3,6,12,8);bubble_sort(\@list, scalar @list);print "@list\n"; sub bubble_sort { my $arrays_ref = shift; my $num = shift; for (my $i = 0; $i < $num - 1; $i++) { for (my $j = 0; $j < $num - $i - 1; $j++) { if ($arrays_ref->[$j] > $arrays_ref->[$j+1]) { my $tmp = $arrays_ref->[$j]; $arrays_ref->[$j] = $arrays_ref->[$j+1]; $arrays_ref->[$j+1] = $tmp; } } }

PASCAL

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var
a:array[1..4]ofinteger;
i,j,temp,n:integer;
begin
read(n);
fori:=1tondoread(a[i]);
fori:=1tondo
forj:=1ton-ido
ifa[j]>a[j+1]then
begin
temp:=a[j];
a[j]:=a[j+1];
a[j+1]:=temp;
end;
fori:=1tondowrite(a[i]);
end.

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
defbubble(bubbleList):
listLength=len(bubbleList)
whilelistLength>0:
foriinrange(listLength-1):
ifbubbleList[i]>bubbleList[i+1]:
bubbleList[i]=bubbleList[i]+bubbleList[i+1]
bubbleList[i+1]=bubbleList[i]-bubbleList[i+1]
bubbleList[i]=bubbleList[i]-bubbleList[i+1]
listLength-=1
printbubbleList
if__name__=='__main__':
bubbleList=[3,4,1,2,5,8,0]
bubble(bubbleList)

posted on 2014-05-26 22:22  Lishenyin  阅读(214)  评论(0)  编辑  收藏  举报

导航