基本概念 php
冒泡排序（BubbleSort）的基本概念是：依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。而後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。至此第一趟結束，將最大的數放到了最後。在第二趟：仍從第一對數開始比較（由於可能因爲第2個數和第3個數的交換，使得第1個數再也不小於第2個數），將小數放前，大數放後，一直比較到倒數第二個數（倒數第一的位置上已是最大的），第二趟結束，在倒數第二的位置上獲得一個新的最大數（其實在整個數列中是第二大的數）。如此下去，重複以上過程，直至最終完成排序。因爲在排序過程當中老是小數往前放，大數日後放，至關於氣泡往上升，因此稱做冒泡排序。 html
用 二重循環實現，外循環變量設爲i，內循環變量設爲j。假若有10個數須要進行排序，則外循環重複9次，內循環依次重複9，8，...，1次。每次進行比較的兩個元素都是與內循環j有關的，它們能夠分別用a[j]和a[j+1]標識，i的值依次爲1,2,...,9，對於每個i,j的值依次爲1,2,...10-i。 python
性能分析
若記錄序列的初始狀態爲"正序"，則冒泡排序過程只需進行一趟排序，在排序過程當中只需進行n-1次比較，且不移動記錄；反之，若記錄序列的初始狀態爲"逆序"，則需進行n(n-1）/2次比較和記錄移動。所以
冒泡
排序總的
時間複雜度
爲O(n*n)。
改進
冒泡排
序法存在的不足及改進方法：
第一，在排序過程當中，執行完最後的排序後，雖然數據已所有排序完備，但程序沒法判斷是否完成排序，爲了解決這一不足，可設置一個標誌位flag，將其初始值設置爲非0，表示被排序的表是一個無序的表，每一次排序開始前設置flag值爲0，在進行數據交換時，修改flag爲非0。在新一輪排序開始時，檢查此標誌，若此標誌爲0，表示上一次沒有作過交換數據，則結束排序；不然進行排序；
第二，當排序的數據比較多時排序的時間會明顯延長。改進方法：
快速排序
：具體作法：任意選取某一記錄（一般取第一個記錄），比較其關鍵字與全部記錄的關鍵字，並將關鍵字比它小的記錄所有放在它的前面，將比它大的記錄均存放在它的後面，這樣，通過一次排序以後，可將全部記錄以該記錄所在的分界點分爲兩部分，而後分別對這兩部分進行快速排序，直至排序完
局部冒泡排序算法對冒泡排序的改進：
在冒泡排序中，一趟掃描有可能無數據交換，也有可能有一次或屢次數據交換，在傳統的冒泡排序算法及近年來的一些改進的算法中，只記錄一趟掃描有無數據交換的信息，對數據交換髮生的位置信息則不予處理。爲了充分利用這一信息，能夠在一趟全局掃描中，對每一反序數據對進行局部冒泡排序處理，稱之爲局部冒泡排序。局部冒泡排序與冒泡排序算法具備相同的
時間複雜度
，而且在正序和逆序的狀況下，所需的關鍵字的比較次數和移動次數徹底相同。因爲局部冒泡排序和冒泡排序的數據移動次數老是相同的，而局部冒泡排序所需關鍵字的比較次數常少於冒泡排序，這意味着局部冒泡排序極可能在平均比較次數上對冒泡排序有所改進，當比較次數較少的優勢不足以抵消其程序複雜度所帶來的額外開銷，而當數據量較大時，局部冒泡排序的時間性能則明顯優於冒泡排序。
算法示例
C語言
void bubble_sort(int *a, int n)
{
int *p1 = a;
int *p2 = a;
int k;
int j;
for (int i = 0; i < n; i++)
{
p2 = p1;
p2++;
for (j = n - i - 1; j > 0; j--)
{
if (*p2 < *p1) // 升序
{
k = *p1;
*p1 = *p2;
*p2 = k;
}
p2++;
}
p1++;
}
}
程序1：
void bubble_sort(int array[],int n)
{
int i,j,flag,temp;
for(i = 0; i < n-1; i++)
{
flag = 1;
for(j = 0; j < n-i-1; j++)
{
if(array[j] > array[j+1])
{
temp= array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = 0;
}
}
if（1 == flag)
{
printf("%d ",i); //首先打印出，在第幾層循環時順序已排好
break; //跳出循環
}
}
return;
}
程序2：（可進行2個數以上大小比較，程序參考做者：
趙傑）
#include<stdio.h>
main()
{
long a,x,k,i[100],s;
char ch;
for(a=0;;a++)
{
printf("輸入一個數，輸完一個數按回車，最後一個數末尾要加n:");
scanf("%ld%c",&i[a],&ch);
if(a==99）
{
printf("注意！輸入的數超過100個");
break;
}
else if(ch=='n')
break;
}
do{
x=0;
for(k=0;k<a;k++)
{
if(i[k]>i[k+1])
{
s=i[k+1];i[k+1]=i[k];
i[k]=s;x++;
}
}
}while(x!=0);
printf("從小到大排列爲：");
for(k=0;k<a;k++)
printf("%ld<",i[k]);
printf("%ld",i[a]);
return 0;
}
C++
#include <iostream>
#define LEN 9
using namespace std;
int main()
{
int nArray[LEN];
for(int i=0;i<LEN;i++)
{
nArray[i]=LEN-i; //賦初值
}
cout<<"原始數據爲："<<endl;
for(int j=0;j<LEN;j++)
{
cout<<nArray[j]<<" ";
}
cout<<endl;
for(int m=LEN-1;m>0;m--)
{
int temp;
for(int n=0;n<m;n++)
{
if(nArray[n]>nArray[n+1])
{
temp=nArray[n];
nArray[n]=nArray[n+1];
nArray[n+1]=temp;
}
}
}
cout<<"排序結果："<<endl;
for(i=0;i<LEN;i++)
{
cout<<nArray[i]<<" ";
}
return 0;
}
PHP
代碼1：
<?php
//
冒泡排序（一維
數組）
function bubble_sort($array)
{
$count = count($array);
if ($count <= 0) return false;
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);
>
代碼2：
<?php
//冒泡排序
function maopaosort($arr)
{
for ($i=0;$i<count($arr)-1;$i++ ) {
for ($j=0;$j<count($arr)-1-$i;$j++ ) {
if($arr[$j]>$arr[$j+1])
{
//交換賦值，不使用中間
變量
$arr[$j]=$arr[$j+1]+$arr[$j];
$arr[$j+1]=$arr[$j]-$arr[$j+1];
$arr[$j]=$arr[$j]-$arr[$j+1];
}
}
}
return $arr;
} // end func
//實例
$arr=array（7,3,6,1,5,2,11,4,44,33,22,88,44）;
print_r(maopaosort($arr));
//結果輸出Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 [5] => 6 [6] => 7 [7] => 11 [8] => 22 [9] => 33 [10] => 44 [11] => 44 [12] => 88 )
>
Ruby
def bubble(arr)
(arr.length-1）.downto（1） do |j|
a1 = arr.dup
j.times do |i|
if arr > arr[i+1]
arr,arr[i+1] = arr[i+1],arr
end
end
break if a1 == arr
end
arr
end
Java
public class Bubblesort {
static void bubblesort(int[] a) {
int temp;
for (int i = 0; i < a.length-1; i++) {//-1是由於最後一個不必再跟它自己比較
for (int j = a.length - 1; j > i ; j--) {
if (a[i] < a[j]) {
temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
}
}
}
Visual Basic
Private Sub Form_Load()
Dim a,c As Variant
Dim i As Integer,j As Integer,temp As Integer,bSwap As Boolean
a = Array（17,45,12,80,50）
For j = 0 To UBound(a) - 1
bSwap = False
For i = 0 To UBound(a) - 1
If (a(i) > a(i + 1）) Then '如果遞減，改成a(i)<a(i+1）
temp = a(i)
a(i) = a(i + 1）
a(i + 1） = temp
bSwap = True
End If
Next
If bSwap = False Then
Exit For
End If
Next
For Each c In a
Debug.Print c;
Next
End Sub
Pascal
program bubble_sort;
var
a:array[1..N] of 1..MAX;
temp,i,j:integer;
begin
randomize;
for i:=1 to N do a:=1+random(MAX);
writeln('Array before sorted:');
for i:=1 to N do write(a,' ');
writeln;
for i:=N-1 downto 1 do
for j:=1 to i do
if a[j]<a[j+1] then
begin
temp:=a[j];
a[j]:=a[j+1];
a[j+1]:=temp;
end;
writeln('Array sorted:');
for i:=1 to N do write(a,' ');
writeln;
writeln('End sorted.');
readln;
end.
C#
static void Main(string[] args)
{
int[] array = { 23,45,16,7,42 };
int length = array.Length - 1;
bool isExchanged = false;
for (int i = 0; i < length; i++)
{
isExchanged = false;
for (int j = length; j > i; j--)
{
if (array[j] > array[j - 1])
{
int temp = array[j];
array[j] = array[j - 1];
array[j - 1] = temp;
isExchanged = true;
}
}
if (!isExchanged)//一遍比較事後若是沒有進行交換則退出循環
break;
}
foreach (int i in array)
{
Console.WriteLine(i);
}
Console.Read();
}
Python
#BubbleSort used python3.1 or python 2.x
def bubble(str):
tmplist = list(str)
count = len(tmplist)
for i in range(0,count-1）[::-1]:
for j in range(0,i）:
if tmplist[j] > tmplist[j+1]:
tmplist[j],tmplist[j+1] = tmplist[j+1],tmplist[j]
return tmplist
#useage:
str = "zbac"
print(bubble(str)) # ['a','b','c','z']
number=[16,134,15,1]
print(bubble(number)) # [1,15,16,134]
JS
function(array){
var length = array.length, temp;
for(var i = 0; i < length - 2; i++){
for (var j = length -1; j >=1;j--) {
if (array[j] < array[j - 1]){
temp = array[j];
array[j] = array[j - 1];
array[j - 1] = temp;
}
}
}
return array;
}
Action Script
var arr:Array=new Array（88,0,4,22,89,0,8,15）;
var temp:int=0;
for(var i:int=0;i<arr.length;i++){
for(var j:int=0;j<arr.length-i;j++){
if(arr[j]>arr[j+1]){
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
for(var t:int=0;t<arr.length;t++){
trace(arr[t]);
}
僞代碼
BUBBLESORT(A)
for i <- 1 to length[A]
do for j <- length[A] downto i + 1
do if A[j]<A[j - 1]
then exchange A[j] <-> A[j-1]
PL/SQL代碼
declare
type varr_type is varray（10） of integer;
varr varr_type:=varr_type（65,32,44,78,20,13,28,99,0,1）;
i integer;
j integer;
t integer;
begin
for i in reverse 1..10 loop --保證最大的那個值在最終的位置上
for j in 1..i-1 loop
if varr(j)>varr(j+1） then
t:=varr(j);
varr(j):=varr(j+1）;
varr(j+1）:=t;
end if;
end loop;
end loop;
for i in 1..10 loop
dbms_output.put_line(varr(i));
end loop;
end;
REAL Basic
Private Sub Form_Load()
Dim a,c As Variant
Dim i As Integer,j As Integer,temp As Integer
a = Array（17,45,12,80,50）
For j = 0 To UBound(a) - 1
For i = 0 To UBound(a) - 1
If (a(j) > a(i)) Then
temp = a(j)
a(j) = a(i）
a(i) = temp
End If
Next
Next
For i=0 to UBound(a)
msgbox str(a(i））
Next
End Sub
變種算法
一個叫作雞尾酒排序（也稱雙向冒泡排序
）的算法，和冒泡排序的「編程複雜度」同樣，但對隨機序列排序性能稍高於普通冒泡排序，可是由於是雙向冒泡，每次循環都雙向檢查，極端環境下會出現額外的比較，致使算法性能的退化，好比「四、五、七、一、二、3」這個序列就會出現退化
