冒泡排序

冒泡排序
冒泡排序（Bubble Sort）又称为泡式排序，是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢「浮」到数列的顶端。
冒泡排序对个项目需要O()的比较次数，且可以原地排序。尽管这个演算法是最简单了解和实作的排序算法之一，但它对于包含大量的元素的数列排序是很没有效率的。
冒泡排序是与插入排序拥有相等的渐近时间复杂度，但是两种算法在需要的交换次数却很大地不同。在最坏的情况，冒泡排序需要次交换，而插入排序只要最多交换。冒泡排序的实现（类似下面）通常会对已经排序好的数列拙劣地执行（），而插入排序在这个例子只需要个运算。因此很多现代的演算法教科书避免使用冒泡排序，而用插入排序取代之。冒泡排序如果能在内部回圈第一次执行时，使用一个旗标来表示有无需要交换的可能，也可以把最优情况下的复杂度降低到。在这个情况，已经排序好的数列就无交换的需要。若在每次走访数列时，把走访顺序反过来，也可以稍微地改进效率。有时候称为鸡尾酒排序，因为演算法会从数列的一端到另一端之间穿梭往返。
冒泡排序演算法的运作如下：
# 比较相邻的元素。如果第一个比第二个大，就交换它们两个。
# 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
# 针对所有的元素重复以上的步骤，除了最后一个。
# 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
由于它的简洁，冒泡排序通常被用来对于程式设计入门的学生介绍演算法的概念。

**-{zh-hant:虚拟码;zh-hans:伪代码}-**
function bubble_sort (array, length) {
var i, j;
for(i from 0 to length-1){
for(j from 0 to length-2-i){
if (arrayj > arrayj+1)
swap(arrayj, arrayj+1)
}
}
}
-{}-
函数 泡沫排序 输入 一个阵列名称为array 其长度为length
i 从 0 到 (length - 1)
j 从 0 到 (length - 2 - i)
如果 arrayj > arrayj + 1
交换 arrayj 和 arrayj + 1 的值
如果结束
j回圈结束
i回圈结束
函数结束

**助记码**
i∈0,N-1)               //循环N-1遍
j∈0,N-1-i)           //每遍循环要处理的无序部分
swap(j,j+1)          //两两排序（升序/降序）
File:冒泡排序.jpg

**实作范例**

**C语言**
#include 
#include 
#define ARR_LEN 255 /* 数组长度上限 */
#define elemType int /* 元素类型 */
/* 泡沫排序 */
/* 1. 从当前元素起，向后依次比较每一对相邻元素，若逆序则互换 */
/* 2. 对所有元素均重复以上步骤，直至最后一个元素 */
/* elemType arr: 排序目标数组; int len: 元素个数 */
void bubbleSort (int arr, int len)
{
	int i, j,temp;
	_Bool exchanged = true;
	
	for (i=0; exchanged && i arrj+1)
			{ /* 相邻元素比较，若逆序则互换（升序为左大于右，逆序反之） */
				temp = arrj;
				arrj = arrj+1;
				arrj+1 = temp;
				exchanged = true; /*只有数值互换过, exchanged才会从false变成true,否则数列已经排序完成,exchanged值仍然为false,没必要排序 */
			}
}
}
}
int main (void) {
	int arrARR_LEN = {3,5,1,-7,4,9,-6,8,10,4};
	int len = 10;
	int i;
	
	bubbleSort (arr, len);
	
	for (i=0; i

**C++**
#include 
using namespace std;
template //整数或浮点数皆可使用,若要使用类(class)或结构体(struct)时必须重载大于(>)运算符
void bubble_sort(T arr, int len) {
	int i, j;
	for (i = 0; i  arrj + 1)
				swap(arrj, arrj + 1);
}
int main() {
	int arr = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 };
	int len = (int) sizeof(arr) / sizeof(*arr);
	bubble_sort(arr, len);
	for (int i = 0; i 

**C#**
private int BubbleSort(int array)
{
var temp = 0;
for (int i = 0; i  arrayj + 1)
{
temp = arrayj;
arrayj = arrayj + 1;
arrayj + 1 = temp;
}
}
}
return array;
}

**JAVA**
private int bubbleSort(int array) {
int temp;
for (int i = 0; i  arrayj + 1) {
temp = arrayj;
arrayj = arrayj + 1;
arrayj + 1 = temp;
Flag = true;
}
}
if (!Flag)
{
break;
}
}
return array;
}

**Ruby**
class Array
def bubble_sort!
for i in 0...(size - 1)
for j in 0...(size - i - 1)
selfj, selfj + 1 = selfj + 1, selfj if selfj > selfj + 1
end
end
self
end
end
puts 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70.bubble_sort!

**JavaScript**
Array.prototype.bubble_sort = function() {
	var i, j, temp;
	for (i = 0; i  thisj + 1) {
				temp = thisj;
				thisj = thisj + 1;
				thisj + 1 = temp;
			}
	return this;
};
var num = 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70;
num.bubble_sort();
for (var i = 0; i 

**Pascal**
输入：（在程式同目录下的文本文件：input.txt）
　一行：等待排序的数（用空格隔开）；
　实例：194 638 124 482 469 245 852 294 484 243 623
输出：（在程式同目录下的文本文件：output.txt）
　一行：已经排好的数（从小到大）；
　实例：124 194 243 245 294 469 482 484 623 638 852 
procedure swap(j:longint);  //交换过程
begin
aj:=aj xor aj+1;
aj+1:=aj xor aj+1;
aj:=aj xor aj+1;
end;
procedure bubble_sort;  //排序过程
var
i,j:longint;
flag:boolean;  //flag标志：若一次排序未发现数据交换，则说明数据已经有序，可以结束排序过程
begin
for i:=n-1 downto 1 do 
begin
flag:=true;
for j:=1 to i do
begin
if aj>aj+1 then 
begin
swap(j);
flag:=false;
end;
end;
if flag then exit;
end;
end;

**Python**
def bubble_sorted(iterable):
new_list = list(iterable)
list_len = len(new_list)
for i in range(list_len-1):
for j in range(list_len - i - 1):
if new_listj > new_listj + 1:
new_listj, new_listj + 1 = new_listj + 1, new_listj
return new_list
范例：
testlist = 27, 33, 28, 4, 2, 26, 13, 35, 8, 14
print('sorted:', bubble_sorted(testlist))
输出：
sorted: 2, 4, 8, 13, 14, 26, 27, 28, 33, 35

**Scratch**
File:Scratchblocks.svg

**VB.NET**
'泡沫排序由大到小的程式，预先产生一储存乱数内容的阵列B，使用中断点check，
'switch 为自定两数交换的sub

Dim i, j, count As Integer

For i = 0 To UBound(b) - 1
Dim check As Boolean = False   '进入排序后设定一布林变数令其初值为false

For j = 0 To UBound(b) - 1 - i
If b(j)  b(j + 1) Then switch(b(j), b(j + 1))
count += 1
check = True
Next
If chk = False Then Exit For
Next

MsgBox("共经过了" & count & "次的排序")

'两数值交换程式
Private Sub switch(ByRef a as integer, ByRef b as integer)
Dim c As Integer
c = a
a = b
b = c
End Sub

**PHP**
function swap(&$x, &$y) {
	$t = $x;
	$x = $y;
	$y = $t;
}
function bubble_sort(&$arr) {//php的阵列视为基本型别，所以必须用传参考才能修改原阵列
	for ($i = 0; $i  $arr$j + 1)
				swap($arr$j, $arr$j + 1);
}
$arr = array(21, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70);
bubble_sort($arr);
for ($i = 0; $i 

**Rust**
pub fn bubble_sort(a: &muti32){
for i in 0..a.len() {
for j in i..a.len() {
if ai > aj {
a.swap(i, j);
}
}
}
}
调用：
let mut a = 5,4,7,1,9;
bubble_sort(&mut a);
println!("{:?}", a);

**Go**
// BubbleSort 冒泡排序. data必须实现sort包中的Interface接口
func BubbleSort(data sort.Interface) {
	n := data.Len()
	for i := 0; i 
调用:
// declare a array
	// this array must implenet sort.Inerface
	data := sort.IntSlice{22, 34, 3, 40, 18, 4}
	BubbleSort(data)

**Objective-C**
- (NSArray*) bubbleSort: (NSArray *) unsortedArray {
if (unsortedArray.count  sortedArrayj+1 integerValue) {
sortedArray exchangeObjectAtIndex:j withObjectAtIndex:j+1;
exchanged = YES;
}
}
if (!exchanged) {
break;
}
}

return sortedArray copy;
}

**Swift**
func bubbleSort(unsortedArray: inout Int){
guard unsortedArray.count > 1 else{
return 
}

for i in 0 .. unsortedArrayj+1 {
unsortedArray.swapAt(j, j+1)
exchanged = true
}
}
if !exchanged {
break
}
}
}
// Test
var list = 2, 3, 5, 7, 4, 8, 6 ,10 ,1, 9
print(list)  
bubbleSort(unsortedArray: &list)
print(list) 

**Shell**
#/bin/bash
read -p "Please enter a sequence: " -a num
for ((i=0;i

**IDL**
FUNCTION BubbleSort, arr
FOR i = 0, N_ELEMENTS(arr) - 2 DO BEGIN
FOR j = i + 1, N_ELEMENTS(arr) - 1 DO BEGIN
IF arri GT arrj THEN BEGIN
temp = arri & arri = arrj & arrj = temp
ENDIF
ENDFOR
ENDFOR
RETURN, arr
END

**Julia (程式语言)**
function BubbleSort(A)
n = length(A)
for i = 1:n
for j = 1:(n-i)
if(Aj>Aj+1)
Aj+1,Aj = Aj,Aj+1
end
end
end
return A
end
# Main Code
A = 16,586,1,31,354,43,3
print(A)               # Original Array
print(BubbleSort(A))   # Bubble Sort Array