如何不讓演算法冒號排序不做無用功

① 冒泡排序法

用冒泡排序法對n個關鍵碼排序，在最好的情況下也就是數據按關鍵碼排序次序有序，只需要依次從頭到尾挨個比較就可以了，因此比較次數為n-1次，關鍵碼不移動，所以0次移動
在最壞的情況下為關鍵碼按排序順序完全逆序，第k趟都有n-k個關鍵碼比較，
因此數據一共要做n*(n-1)/2次比較，移動次數則為3n*(n-1)/2

這樣就是錯誤A

② 什麼是冒泡排序演算法

冒泡排序演算法：重復地走訪過要排序的元素列，依次比較兩個相鄰的元素，如果他們的順序（如從大到小、首字母從A到Z）錯誤就把他們交換過來。走訪元素的工作是重復地進行直到沒有相鄰元素需要交換，也就是說該元素已經排序完成。

這個演算法的名字由來是因為越大的元素會經由交換慢慢「浮」到數列的頂端（升序或降序排列），就如同碳酸飲料中二氧化碳的氣泡最終會上浮到頂端一樣，故名「冒泡排序」。

(2)如何不讓演算法冒號排序不做無用功擴展閱讀：

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

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

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

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

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

③ C語言冒泡排序原理

經典排序演算法 - 冒泡排序Bubble sort
原理是臨近的數字兩兩進行比較,按照從小到大或者從大到小的順序進行交換,
這樣一趟過去後,最大或最小的數字被交換到了最後一位,
然後再從頭開始進行兩兩比較交換,直到倒數第二位時結束,其餘類似看例子
例子為從小到大排序,
原始待排序數組| 6 | 2 | 4 | 1 | 5 | 9 |

第一趟排序(外循環)
第一次兩兩比較6 > 2交換(內循環)
交換前狀態| 6 | 2 | 4 | 1 | 5 | 9 |
交換後狀態| 2 | 6 | 4 | 1 | 5 | 9 |

第二次兩兩比較,6 > 4交換
交換前狀態| 2 | 6 | 4 | 1 | 5 | 9 |
交換後狀態| 2 | 4 | 6 | 1 | 5 | 9 |

第三次兩兩比較,6 > 1交換
交換前狀態| 2 | 4 | 6 | 1 | 5 | 9 |
交換後狀態| 2 | 4 | 1 | 6 | 5 | 9 |

第四次兩兩比較,6 > 5交換
交換前狀態| 2 | 4 | 1 | 6 | 5 | 9 |
交換後狀態| 2 | 4 | 1 | 5 | 6 | 9 |

第五次兩兩比較,6 < 9不交換
交換前狀態| 2 | 4 | 1 | 5 | 6 | 9 |
交換後狀態| 2 | 4 | 1 | 5 | 6 | 9 |

第二趟排序(外循環)
第一次兩兩比較2 < 4不交換
交換前狀態| 2 | 4 | 1 | 5 | 6 | 9 |
交換後狀態| 2 | 4 | 1 | 5 | 6 | 9 |

第二次兩兩比較,4 > 1交換
交換前狀態| 2 | 4 | 1 | 5 | 6 | 9 |
交換後狀態| 2 | 1 | 4 | 5 | 6 | 9 |

第三次兩兩比較,4 < 5不交換
交換前狀態| 2 | 1 | 4 | 5 | 6 | 9 |
交換後狀態| 2 | 1 | 4 | 5 | 6 | 9 |

第四次兩兩比較,5 < 6不交換
交換前狀態| 2 | 1 | 4 | 5 | 6 | 9 |
交換後狀態| 2 | 1 | 4 | 5 | 6 | 9 |

第三趟排序(外循環)
第一次兩兩比較2 > 1交換
交換後狀態| 2 | 1 | 4 | 5 | 6 | 9 |
交換後狀態| 1 | 2 | 4 | 5 | 6 | 9 |

第二次兩兩比較,2 < 4不交換
交換後狀態| 1 | 2 | 4 | 5 | 6 | 9 |
交換後狀態| 1 | 2 | 4 | 5 | 6 | 9 |

第三次兩兩比較,4 < 5不交換
交換後狀態| 1 | 2 | 4 | 5 | 6 | 9 |
交換後狀態| 1 | 2 | 4 | 5 | 6 | 9 |

第四趟排序(外循環)無交換
第五趟排序(外循環)無交換

排序完畢,輸出最終結果1 2 4 5 6 9

#include <stdio.h>
int main()
{
int i,j,temp;
int a[6]={6,2,4,1,5,9}; //6個元素
for(j=0;j<5;j++) //共進行5輪外循環
{ for (i=0;i<5-j;i++) //每輪內循環結束時，第(j+1)大的數排到正確的位置上（沉底）
if (a[i]>a[i+1]) //每次比較相信的二個數，若大小順序不對，就交換它們相互位置
{ temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;}
}
for(i=1;i<6;i++) //輸出排序後的所有元素
printf("%3d,",a[i] );
printf("\n");
return 0;
}

④ 冒泡排序的演算法原理

冒泡排序演算法的運作如下：（從後往前） 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。 針對所有的元素重復以上的步驟，除了最後一個。 持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

⑤ 冒泡排序法是如何排序的

冒泡排序演算法的原理：

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

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

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

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

(5)如何不讓演算法冒號排序不做無用功擴展閱讀：

冒泡排序（Bubble Sort），是一種計算機科學領域的較簡單的排序演算法。

它重復地走訪過要排序的元素列，依次比較兩個相鄰的元素，如果順序（如從大到小、首字母從Z到A）錯誤就把他們交換過來。走訪元素的工作是重復地進行直到沒有相鄰元素需要交換，也就是說該元素列已經排序完成。

這個演算法的名字由來是因為越小的元素會經由交換慢慢「浮」到數列的頂端（升序或降序排列），就如同碳酸飲料中二氧化碳的氣泡最終會上浮到頂端一樣，故名「冒泡排序」。

演算法穩定性：

冒泡排序就是把小的元素往前調或者把大的元素往後調。比較是相鄰的兩個元素比較，交換也發生在這兩個元素之間。所以，如果兩個元素相等，是不會再交換的；如果兩個相等的元素沒有相鄰，那麼即使通過前面的兩兩交換把兩個相鄰起來，這時候也不會交換，所以相同元素的前後順序並沒有改變，所以冒泡排序是一種穩定排序演算法。

⑥ 關於冒泡排序法的問題

很明顯答案多做了好多次無用功。
你寫的這個是標準的冒泡排序法，比答案要優化些。當然，冒泡排序還有更優化的版本。

⑦ C++ 冒泡排序法

代碼：

#include&lt;iostream&gt;

using namespace std;

void print(int arr[],int n)

{

for(int j=0;j&lt;n;j++)

{

cout&lt;&lt;arr[j]&lt;&lt;"";

}

cout&lt;&lt;endl;

}

void BubbleSort(int arr[],int n)

{

for(int i=0;i&lt;n-1;i++)

{

for(int j=0;j&lt;n-i-1;j++)

{

if(arr[j]&gt;arr[j+1])

{

int temp=arr[j];

arr[j]=arr[j+1];

arr[j+1]=temp;

}

}

}

}

int main()

{

int s[10]={8,1,9,7,2,4,5,6,10,3};

cout&lt;&lt;"初始序列：";

print(s,10);

BubbleSort(s,10);

cout&lt;&lt;"排序結果：";

print(s,10);

system("pause");

}

(7)如何不讓演算法冒號排序不做無用功擴展閱讀：

冒泡排序的基本思想：比較相鄰的元素，如果反序則交換。通過第一趟排序能找出最大的元素，並使最大的元素移至最後一位，然後通過第二次排序使次大的元素移至倒數第二位，以此類推，直至所有元素有序。

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

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

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

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

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

⑧ C語言冒泡排序法

冒泡排序每一趟排序把最大的放在最右邊。

比如：

87 12 56 45 78

87和12交換：12 87 56 45 78

87和56交換： 56 87 45 78

87和45交換： 45 87 78

87和78交換： 78 87

到此第一趟排序結束，接下來的每一趟排序都是這樣。

#include<stdio.h>
voidPrint(int*num,intn)
{
inti;
for(i=0;i<n;i++)
printf("%d",num[i]);
puts("
");
return;
}
voidBubble_Sort(int*num,intn)
{
inti,j;
for(i=0;i<n;i++)
{
for(j=0;i+j<n-1;j++)
{
if(num[j]>num[j+1])
{
inttemp=num[j];
num[j]=num[j+1];
num[j+1]=temp;
}
Print(num,n);
}
}
return;
}
intmain()
{
intnum[8]={87,12,56,45,78};
Bubble_Sort(num,5);
return0;
}

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

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

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

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

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

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

(9)如何不讓演算法冒號排序不做無用功擴展閱讀：

演算法優化：當裡面的一層循環在某次掃描中沒有交換則說明此時數組已經全部有序，無需再再次掃描。

所以可以添加一個標記每交換一次就進行標記，如果某次沒有沒有標記就說明已經有序了

寫冒泡排序可以排序多個字元串。假設對4個字元串進行排序，每個字元串不超過10個 ，那麼可以把這三個字元串看成一個二維數組，這樣一個一位數組的指針就可以訪問該數組，然後根據冒泡排序的原理就可以排序了。

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

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