冒泡排序

冒泡排序（Bubble Sort）又称为泡式排序，是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢「浮」到数列的顶端。
冒泡排序对formula_1个项目需要O(formula_2)的比较次数，且可以原地排序。尽管这个演算法是最简单了解和实作的排序算法之一，但它对于包含大量的元素的数列排序是很没有效率的。
冒泡排序是与插入排序拥有相等的渐近时间复杂度，但是两种算法在需要的交换次数却很大地不同。在最坏的情况，冒泡排序需要formula_3次交换，而插入排序只要最多formula_4交换。冒泡排序的实现（类似下面）通常会对已经排序好的数列拙劣地执行（formula_3），而插入排序在这个例子只需要formula_4个运算。因此很多现代的演算法教科书避免使用冒泡排序，而用插入排序取代之。冒泡排序如果能在内部回圈第一次执行时，使用一个旗标来表示有无需要交换的可能，也可以把最优情况下的复杂度降低到formula_4。在这个情况，已经排序好的数列就无交换的需要。若在每次走访数列时，把走访顺序反过来，也可以稍微地改进效率。有时候称为鸡尾酒排序，因为演算法会从数列的一端到另一端之间穿梭往返。
冒泡排序演算法的运作如下：
由于它的简洁，冒泡排序通常被用来对于程式设计入门的学生介绍演算法的概念。
实作范例.
C语言.
<syntaxhighlight lang="c" line="1">
/* 泡沫排序 */
/* 1. 从当前元素起，向后依次比较每一对相邻元素，若逆序则互换 */
/* 2. 对所有元素均重复以上步骤，直至最后一个元素 */
/* elemType arr[]: 排序目标数组; int len: 元素个数 */
void bubbleSort (int arr[], int len)
 int i, j,temp;
 _Bool exchanged = true;
 for (i=0; exchanged && i<len-1; i++){ /* 外回圈为排序趟数，len个数进行len-1趟,只有交换过,exchanged值为true才有必要执行回圈,否则exchanged值为false不执行回圈 */
 for (j=0; j<len-1-i; j++) 
 { /* 内回圈为每趟比较的次数，第i趟比较len-i次 */
 if (arr> arr[j+1)
 { /* 相邻元素比较，若逆序则互换（升序为左大于右，逆序反之） */
 temp = arr;
 arr= arr[j+1;
 arr[j+1] = temp;
 exchanged = true; /*只有数值互换过, exchanged才会从false变成true,否则数列已经排序完成,exchanged值仍然为false,没必要排序 */
int main (void) {
 int arr = {3,5,1,-7,4,9,-6,8,10,4};
 int len = 10;
 int i;
 bubbleSort (arr, len);
 for (i=0; i<len; i++)
 printf ("%d\t", arr);
 putchar ('\n');
 return 0;
</syntaxhighlight>
C++.
<syntaxhighlight lang = "cpp">
using namespace std;
template<typename T> //整数或浮点数皆可使用,若要使用类(class)或结构体(struct)时必须重载大于(>)运算符
void bubble_sort(T arr[], int len) {
 int i, j;
 for (i = 0; i < len - 1; i++)
 for (j = 0; j < len - 1 - i; j++)
 if (arr> arr[j + 1)
 swap(arrarr[j + 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 < len; i++)
 cout Â« arr Â« ' ';
 cout Â« endl;
 float arrf[] = { 17.5, 19.1, 0.6, 1.9, 10.5, 12.4, 3.8, 19.7, 1.5, 25.4, 28.6, 4.4, 23.8, 5.4 };
 len = (float) sizeof(arrf) / sizeof(*arrf);
 bubble_sort(arrf, len);
 for (int i = 0; i < len; i++)
 cout Â« arrf Â« ' 'Â«endl;
 return 0;
</syntaxhighlight>
C#.
<syntaxhighlight lang="Csharp">
private int[] BubbleSort(int[] array)
</syntaxhighlight>
JAVA.
<syntaxhighlight lang = "java">
private int[] bubbleSort(int[] array) {
</syntaxhighlight>
Ruby.
<syntaxhighlight lang="ruby">
class Array
end
puts 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70.bubble_sort!
</syntaxhighlight>
JavaScript.
<syntaxhighlight lang="javascript">
Array.prototype.bubble_sort = function() {
 var i, j, temp;
 for (i = 0; i < this.length - 1; i++)
 for (j = 0; j < this.length - 1 - i; j++)
 if (this> this[j + 1) {
 temp = this;
 this= this[j + 1;
 this+ 1 = temp;
 return this;
var num = 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70;
num.bubble_sort();
for (var i = 0; i < num.length; i++)
 document.body.innerHTML += num + " ";
</syntaxhighlight>
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 
<syntaxhighlight lang="pascal">
procedure swap(j:longint); //交换过程
begin
end;
procedure bubble_sort; //排序过程
var
begin
end;
</syntaxhighlight>
Python.
<syntaxhighlight lang="python">
def bubble_sorted(iterable):
</syntaxhighlight>
范例：
<syntaxhighlight lang="python">
testlist = 33, 28, 4, 2, 26, 13, 35, 8, 14
print('sorted:', bubble_sorted(testlist))
</syntaxhighlight>
输出：
<syntaxhighlight lang="python">
sorted: 4, 8, 13, 14, 26, 27, 28, 33, 35
</syntaxhighlight>
VB.NET.
<syntaxhighlight lang="vbnet">
</syntaxhighlight>
PHP.
<syntaxhighlight lang="php">
function swap(&$x, &$y) {
 $t = $x;
 $x = $y;
 $y = $t;
function bubble_sort(&$arr) {//php的阵列视为基本型别，所以必须用传参考才能修改原阵列
 for ($i = 0; $i < count($arr) - 1; $i++)
 for ($j = 0; $j < count($arr) - 1 - $i; $j++)
 if ($arr[$j] > $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 < count($arr); $i++)
 echo $arr[$i] . ' ';
</syntaxhighlight>
Rust.
<syntaxhighlight lang="rust">
pub fn bubble_sort(a: &mut){
</syntaxhighlight>
调用：
<syntaxhighlight lang="rust">
</syntaxhighlight>
Go.
<syntaxhighlight lang="go">
// BubbleSort 冒泡排序. data必须实现sort包中的Interface接口
func BubbleSort(data sort.Interface) {
 n := data.Len()
 for i := 0; i < n-1; i++ {
 isChanged := false
 for j := 0; j < n-1-i; j++ {
 if data.Less(j, j+1) {
 data.Swap(j, j+1)
 isChanged = true
 if !isChanged {
 break
</syntaxhighlight>
调用:
<syntaxhighlight lang="go">
 // this array must implenet sort.Inerface
 BubbleSort(data)
</syntaxhighlight>
Objective-C.
<syntaxhighlight lang="Objective-C" line="1">
- (NSArray*) bubbleSort: (NSArray *) unsortedArray {
</syntaxhighlight>
Swift.
<syntaxhighlight lang="Swift" line="1">
func bubbleSort(unsortedArray: inout ){
// Test
var list = 3, 5, 7, 4, 8, 6 ,10 ,1, 9
print(list) 
bubbleSort(unsortedArray: &list)
print(list) 
</syntaxhighlight>
Shell.
<syntaxhighlight lang="Shell" line="1">
read -p "Please enter a sequence: " -a num
for ((i=0;i<$[${#num[*]}-1];i++));do
done
</syntaxhighlight>
IDL.
<syntaxhighlight lang="idl" line="1">
FUNCTION BubbleSort, arr
END
</syntaxhighlight>
Julia (程式语言).
<syntaxhighlight lang="julia">
function BubbleSort(A)
end
A = [16,586,1,31,354,43,3]
print(A) # Original Array
print(BubbleSort(A)) # Bubble Sort Array
</syntaxhighlight>