氣泡演算法

Ⅰ 誰能講一下冒泡排序原理

冒泡排序演算法的原理如下：

1，比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。

2，對每一對相鄰元素做同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。

3，針對所有的元素重復以上的步驟，除了最後一個。

4，持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

。

2，演算法穩定性：

冒泡排序就是把小的元素往前調或者把大的元素往後調。比較是相鄰的兩個元素比較，交換也發生在這兩個元素之間。

所以，如果兩個元素相等，是不會再交換的；如果兩個相等的元素沒有相鄰，那麼即使通過前面的兩兩交換把兩個相鄰起來，這時候也不會交換，所以相同元素的前後順序並沒有改變，所以冒泡排序是一種穩定排序演算法。

Ⅱ 計算機中冒泡排序是怎麼回事

冒泡排序你可以把一個數組的元素看成是一串氣泡，每次都要比較相鄰的兩個氣泡的大小，大的放下面，輕的放上面，
第一輪比較完，所有氣泡中最重的（也是最大的）放最下面，
第二輪比較完後，第二大的氣泡放倒數第二個位置
依此類推，直到最輕的氣泡在最上面，所有氣泡從輕到重排放好，共比較n-1次（n是數組中元素個個數）

給你個最常規的演算法
#include<stdio.h>
void main()
{
int a[10];
int i,j;
int temp=0;
for(i=0;i<10;i++)//輸入10個數組元素
{
printf("input %d number: ",i+1);
scanf("%d",&a[i]);
}

printf("排序前數組元素：\n");//冒泡排序前輸出10個數組元素
for(i=0;i<10;i++)
printf("%d\n",a[i]);
printf("\n");

for(i=0;i<9;i++)//冒泡排序演算法，共9輪比較
for(j=0;j<9-i;j++)//每一輪比較完，剩下的沒有排序的元素就少一個
if(a[j]>a[j+1])
{
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}

printf("排序後數組元素：\n");//冒泡排序後輸出10個數組元素
for(i=0;i<10;i++)
printf("%d\n",a[i]);
printf("\n");
}

Ⅲ 一個C氣泡排序演算法代碼的讀問題

是說如果a[i]的值大於a[i+1] 執行大括弧里的內容，用t做一個中間量，將a[i]的值和a[i+1]的值互換，由此推斷是要求升序排列 ，先比較，再決定是否互換

Ⅳ c語言冒泡演算法!!!

冒泡排序的演算法分析與改進
交換排序的基本思想是：兩兩比較待排序記錄的關鍵字，發現兩個記錄的次序相反時即進行交換，直到沒有反序的記錄為止。
應用交換排序基本思想的主要排序方法有：冒泡排序和快速排序。

冒泡排序

1、排序方法
將被排序的記錄數組R[1..n]垂直排列，每個記錄R[i]看作是重量為R[i].key的氣泡。根據輕氣泡不能在重氣泡之下的原則，從下往上掃描數組R：凡掃描到違反本原則的輕氣泡，就使其向上"飄浮"。如此反復進行，直到最後任何兩個氣泡都是輕者在上，重者在下為止。
（1）初始
R[1..n]為無序區。

（2）第一趟掃描
從無序區底部向上依次比較相鄰的兩個氣泡的重量，若發現輕者在下、重者在上，則交換二者的位置。即依次比較(R[n]，R[n-1])，(R[n-1]，R[n-2])，…，(R[2]，R[1])；對於每對氣泡(R[j+1]，R[j])，若R[j+1].key<R[j].key，則交換R[j+1]和R[j]的內容。
第一趟掃描完畢時，"最輕"的氣泡就飄浮到該區間的頂部，即關鍵字最小的記錄被放在最高位置R[1]上。

（3）第二趟掃描
掃描R[2..n]。掃描完畢時，"次輕"的氣泡飄浮到R[2]的位置上……
最後，經過n-1 趟掃描可得到有序區R[1..n]
注意：
第i趟掃描時，R[1..i-1]和R[i..n]分別為當前的有序區和無序區。掃描仍是從無序區底部向上直至該區頂部。掃描完畢時，該區中最輕氣泡飄浮到頂部位置R[i]上，結果是R[1..i]變為新的有序區。

2、冒泡排序過程示例
對關鍵字序列為49 38 65 97 76 13 27 49的文件進行冒泡排序的過程

3、排序演算法
（1）分析
因為每一趟排序都使有序區增加了一個氣泡，在經過n-1趟排序之後，有序區中就有n-1個氣泡，而無序區中氣泡的重量總是大於等於有序區中氣泡的重量，所以整個冒泡排序過程至多需要進行n-1趟排序。
若在某一趟排序中未發現氣泡位置的交換，則說明待排序的無序區中所有氣泡均滿足輕者在上，重者在下的原則，因此，冒泡排序過程可在此趟排序後終止。為此，在下面給出的演算法中，引入一個布爾量exchange，在每趟排序開始前，先將其置為FALSE。若排序過程中發生了交換，則將其置為TRUE。各趟排序結束時檢查exchange，若未曾發生過交換則終止演算法，不再進行下一趟排序。

（2）具體演算法
void BubbleSort(SeqList R)
{ //R（l..n)是待排序的文件，採用自下向上掃描，對R做冒泡排序
int i，j；
Boolean exchange； //交換標志
for(i=1;i<n;i++){ //最多做n-1趟排序
exchange=FALSE； //本趟排序開始前，交換標志應為假
for(j=n-1;j>=i；j--) //對當前無序區R[i..n]自下向上掃描
if(R[j+1].key<R[j].key){//交換記錄
R[0]=R[j+1]； //R[0]不是哨兵，僅做暫存單元
R[j+1]=R[j]；
R[j]=R[0]；
exchange=TRUE； //發生了交換，故將交換標志置為真
}
if(!exchange) //本趟排序未發生交換，提前終止演算法
return；
} //endfor(外循環)
} //BubbleSort
4、演算法分析
（1）演算法的最好時間復雜度
若文件的初始狀態是正序的，一趟掃描即可完成排序。所需的關鍵字比較次數C和記錄移動次數M均達到最小值：
Cmin=n-1
Mmin=0。
冒泡排序最好的時間復雜度為O(n)。

（2）演算法的最壞時間復雜度
若初始文件是反序的，需要進行n-1趟排序。每趟排序要進行n-i次關鍵字的比較(1≤i≤n-1)，且每次比較都必須移動記錄三次來達到交換記錄位置。在這種情況下，比較和移動次數均達到最大值：
Cmax=n(n-1)/2=O(n2)
Mmax=3n(n-1)/2=O(n2)
冒泡排序的最壞時間復雜度為O(n2)。

（3）演算法的平均時間復雜度為O(n2)
雖然冒泡排序不一定要進行n-1趟，但由於它的記錄移動次數較多，故平均時間性能比直接插入排序要差得多。

（4）演算法穩定性
冒泡排序是就地排序，且它是穩定的。

5、演算法改進
上述的冒泡排序還可做如下的改進：
(1)記住最後一次交換發生位置lastExchange的冒泡排序
在每趟掃描中，記住最後一次交換發生的位置lastExchange，（該位置之前的相鄰記錄均已有序）。下一趟排序開始時，R[1..lastExchange-1]是有序區，R[lastExchange..n]是無序區。這樣，一趟排序可能使當前有序區擴充多個記錄，從而減少排序的趟數。具體演算法【參見習題】。

(2) 改變掃描方向的冒泡排序
①冒泡排序的不對稱性
能一趟掃描完成排序的情況：
只有最輕的氣泡位於R[n]的位置，其餘的氣泡均已排好序，那麼也只需一趟掃描就可以完成排序。
【例】對初始關鍵字序列12，18，42，44，45，67，94，10就僅需一趟掃描。
需要n-1趟掃描完成排序情況：
當只有最重的氣泡位於R[1]的位置，其餘的氣泡均已排好序時，則仍需做n-1趟掃描才能完成排序。
【例】對初始關鍵字序列：94，10，12，18，42，44，45，67就需七趟掃描。

②造成不對稱性的原因
每趟掃描僅能使最重氣泡"下沉"一個位置，因此使位於頂端的最重氣泡下沉到底部時，需做n-1趟掃描。

③改進不對稱性的方法
在排序過程中交替改變掃描方向，可改進不對稱性。

Ⅳ 冒泡排序法是什麼

冒泡排序的英文Bubble Sort，是一種最基礎的交換排序。

大家一定都喝過汽水，汽水中常常有許多小小的氣泡，嘩啦嘩啦飄到上面來。這是因為組成小氣泡的二氧化碳比水要輕，所以小氣泡可以一點一點向上浮動。而我們的冒泡排序之所以叫做冒泡排序，正是因為這種排序演算法的每一個元素都可以像小氣泡一樣，根據自身大小，一點一點向著數組的一側移動。

冒泡排序演算法的原理如下：

• 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。

• 對每一對相鄰元素做同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。

• 針對所有的元素重復以上的步驟，除了最後一個。

• 持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

具體如何來移動呢？讓我們來看一個栗子：



希望對您有所幫助！~

Ⅵ 氣泡法的演算法示例

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),演算法為穩定的排序方



Ⅶ c語言中的氣泡法是怎麼回事啊

又稱冒泡排序法。
基本思路：對尚未排序的各元素從頭到尾依次比較相鄰的兩個元素是否逆序（與欲排順序相反），若逆序就交換這兩元素，經過第一輪比較排序後便可把最大（或最小）的元素排好，然後再用同樣的方法把剩下的元素逐個進行比較，就得到了你所要的順序。可以看出如果有 n 個元素，那麼一共要進行 n-1 輪比較，第 i 輪要進行 j=n-i 次比較。（如：有5個元素，則要進行5-1輪比較。第3輪則要進行5-3次比較）

下面使用c++語言編寫
#include<iostream.h>
void main()
{
int a[n],i,j,temp;
cout<<"請輸入數字："<<endl;
for(i=0;i<=n;i++)
cin>>a; //依次輸入n個整數
for(i=0;i<n;i++)
{
for（j=i+1;j<n;j++）
if(a<a[j]) //利用臨時變數temp交換順序
{ temp=a[j];
a[j]=a;
a=temp;
}
cout<<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(n2),演算法為穩定的排序方
冒泡排序c++代碼
#include <iostream.h>
void BubbleSort(int* pData,int Count)
{
int iTemp;
for(int i=1;i<Count;i++)
{
for(int j=Count-1;j>=i;j--)
{
if(pData[j]<pData[j-1])
{
iTemp = pData[j-1];
pData[j-1] = pData[j];
pData[j] = iTemp;
}
}
}
}
void main()
{
int data[] = {10,9,8,7,6,5,4};
BubbleSort(data,7);
for (int i=0;i<7;i++)
cout<<data[i]<<" ";
cout<<"\n";
}
冒泡排序Ruby代碼
def bubble(arr)
(arr.length-1).downto(1) do |j|
a1 = arr.p
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代碼
static void BubbleSort(int a []){
int temp=0;
for (int i = 0; i < a.length ; i++) {
for (int j = 0; j < a.length - i - 1; j++){
if (a[j]>a[j + 1]){ //把這里改成大於，就是升序了
temp=a[j];
a[j]=a[j + 1];
a[j + 1]=temp;
}
}
}
}
冒泡排序Visual Basic代碼
Option Explicit
Private Sub Form_click()
Dim a, c As Variant
Dim i As Integer, temp As Integer, w As Integer
a = Array(12, 45, 17, 80, 50)
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
End If
Next
For Each c In a
Print c;
Next
End Sub
冒泡排序Pascal代碼
<i id="bks_9tjbxut2">program bubblesort;
const
N=20;
MAX=10;
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#代碼
public void BubbleSort(int[] array) {
int length = array.Length;
for (int i = 0; i <= length - 2; i++) {
for (int j = length - 1; j >= 1; j--) {
if (array[j] < array[j - 1] ) {
int temp = array[j];
array[j] = array[j - 1];
array[j - 1] = temp;
}
}
}
}
冒泡排序Python代碼
#algo
def bubble(list):
count = len(list) -1
while count > 0 :
i = 0
onceflag = True
while i < count :
if int(list) > int(list[i+1]) :
tmp = list
list = list [i+1]
list[i+1] =tmp
onceflag = False
i = i + 1
if onceflag : return list
count = count - 1
return list
#test
li = [1,9,8,5,4,3,6,7,0,2]
print bubble(li)
冒泡排序法的改進
比如用冒泡排序將4、5、7、1、2、3這6個數排序。在該列中，第二趟排序結束後，數組已排好序，但計算機此時並不知道已經反排好序，計算機還需要進行一趟比較，如果這一趟比較，未發生任何數據交換，則知道已排序好，可以不再進行比較了。因而第三趟比較還需要進行，但第四、五趟比較則是不必要的。為此，我們可以考慮程序的優化。
為了標志在比較中是否進行了，設一個布爾量flag。在進行每趟比較前將flag置成true。如果在比較中發生了數據交換，則將flag置為false，在一趟比較結束後，再判斷flag，如果它仍為true（表明在該趟比較中未發生一次數據交換）則結束排序，否則進行下一趟比較。
性能分析
若記錄序列的初始狀態為"正序"，則冒泡排序過程只需進行一趟排序，在排序過程中只需進行n-1次比較，且不移動記錄；反之，若記錄序列的初始狀態為"逆序"，則需進行n(n-1)/2次比較和記錄移動。因此冒泡排序總的時間復雜度為O(n*n)。

Ⅸ 起泡排序和冒泡排序是不是一個概念

C實現冒泡排序演算法

最簡單的排序方法是冒泡排序方法。 這種方法的基本思想是，將待排序的元素看作是豎著排列的「氣泡」，較小的元素比較輕，從而要往上浮。 在冒泡排序演算法中我們要對這個「氣泡」序列處理若干遍。所謂一遍處理，就是自底向上檢查一遍這個序列，並時刻注意兩個相鄰的元素的順序是否正確。如果發現兩個相鄰元素的順序不對，即「輕」的元素在下面，就交換它們的位置。顯然，處理一遍之後，「最輕」的元素就浮到了最高位置；處理二遍之後，「次輕」的元素就浮到了次高位置。在作第二遍處理時，由於最高位置上的元素已是「最輕」元素，所以不必檢查。一般地，第i遍處理時，不必檢查第i高位置以上的元素，因為經過前面i-1遍的處理，它們已正確地排好序。 這個演算法可實現如下。

C語言程序：(TC 2.0通過) void doit(float* in,int count) { int x; int y; float temp; for(y=0;y<count-1;y++) { for(x=1;x<count-y;x++) { if((*(in+x))>(*(in+x-1))) { temp=(*(in+x-1)); (*(in+x-1))=(*(in+x)); (*(in+x))=temp; } } } }