排序演算法冒泡排序
A. 冒泡排序演算法
冒泡排序（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，凡掃描到違反本原則的輕氣泡，就使其向上"漂浮"，如此反復進行，直至最後任何兩個氣泡都是輕者在上，重者在下為止。
演算法示例
49 13 13 13 13 13 13 13
38 49 27 27 27 27 27 27
65 38 49 38 38 38 38 38
97 65 38 49 49 49 49 49
76 97 65 49 49 49 49 49
13 76 97 65 65 65 65 65
27 27 76 97 76 76 76 76
49 49 49 76 97 97 97 97
Procere BubbleSort(Var R : FileType) //從下往上掃描的起泡排序//
Begin
For I := 1 To N-1 Do //做N-1趟排序//
begin
NoSwap := True; //置未排序的標志//
For J := N - 1 DownTo 1 Do //從底部往上掃描//
begin
If R[J+1]< R[J] Then //交換元素//
begin
Temp := R[J+1]; R[J+1 := R[J]; R[J] := Temp;
NoSwap := False
end;
end;
If NoSwap Then Return//本趟排序中未發生交換，則終止演算法//
end
End; //BubbleSort//
該演算法的時間復雜性為O(n^2),演算法為穩定的排序方
編輯本段
冒泡排序代碼
AAuto
bubble_sort = function(array){
var temp;
for( i=1;#array ){
//i前面的已經是最小的數，並排序好了
for(j=#array;i+1;-1){
//挨個比較
if(array[j]<array[j-1]){
//小的總是往前排
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
void bubble_sort(int *x, int n)
{
int j, k, h, t;
for (h=n-1; h>0; h=k) /*循環到沒有比較范圍*/
{
for (j=0, k=0; j<h; j++) /*每次預置k=0，循環掃描後更新k*/
{
if (*(x+j) > *(x+j+1)) /*大的放在後面，小的放到前面*/
{
t = *(x+j);
*(x+j) = *(x+j+1);
*(x+j+1) = t; /*完成交換*/
k = j; /*保存最後下沉的位置。這樣k後面的都是排序排好了的。*/
}
}
}
}
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 i=0;i<LEN;i++)cout<<nArray[i]<<" ";
cout<<endl;
//開始冒泡
{
int temp;
for(int i=LEN-1;i>0;i--)
for(int j=0;j<i;j++)
{
if(nArray[j]>nArray[j+1])
{
temp=nArray[j];
nArray[j]=nArray[j+1];
nArray[j+1]=temp;
}
}
}
//結束冒泡
cout<<"排序結果:"<<endl;
for(int i=0;i<LEN;i++)cout<<nArray[i]<<" ";
return 0;
}
B. 冒泡排序
冒泡排序（Bubble Sort）是一種典型的交換排序演算法，通過交換數據元素的位置進行排序。
一、演算法基本思想
（1）基本思想
冒泡排序的基本思想就是：從無序序列頭部開始，進行兩兩比較，根據大小交換位置，直到最後將最大（小）的數據元素交換到了無序隊列的隊尾，從而成為有序序列的一部分；下一次繼續這個過程，直到所有數據元素都排好序。
演算法的核心在於每次通過兩兩比較交換位置，選出剩餘無序序列里最大（小）的數據元素放到隊尾。
（2）運行過程
冒泡排序演算法的運作如下：
1、比較相鄰的元素。如果第一個比第二個大（小），就交換他們兩個。
2、對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大（小）的數。
3、針對所有的元素重復以上的步驟，除了最後已經選出的元素（有序）。
4、持續每次對越來越少的元素（無序元素）重復上面的步驟，直到沒有任何一對數字需要比較，則序列最終有序。
（3）示例
java 的如何實現冒泡演算法呢？
其實有兩種方法
一種是正序
/*
* 正序冒泡
* */
public static void sortListAsc(Integer[] list){
if(list.length>0){
for(int i=0;i
for(int j=0;j
int exchange=0;
if(list[j]>list[j+1]){
exchange= list[j+1];
list[j+1]=list[j];
list[j]=exchange;
}
}
}
}
for(Integer k:list){
System.out.println(k);
}
}
一種是反序
/*
* 反序冒泡
* */
public static void sortListDesc(Integer[] list){
if(list.length>0){
for(int i=(list.length-1);i>0;i--){
for(int j=(list.length-1);j>0;j--){
int a=0;
if(list[j]
a=list[j-1];
list[j-1]=list[j];
list[j]=a;
}
}
}
}
}
雖然實現的目標是相同的，但是實現的原理也一樣 只不過流程是逆向的
完成之後便是如此
如果使用Stiring 字元串的compareTo 也可以是實現類似功能
不過這個比較的是字元串的ASCII碼值的大小 ，可以應用於數字字元串的比較， 如此冒泡依舊可以使用。
//實現字元串的冒泡
public static String[]sortAscII(String[] list){
if(list.length>0){
for(int i=(list.length-1);i>0;i--){
for(int j=(list.length-1);j>0;j--){
String a="";
if(list[j].compareTo(list[j-1])<0 ){
a=list[j-1];
list[j-1]=list[j];
list[j]=a;
}
}
}
}
return list;
}