如何不让算法冒号排序不做无用功

① 冒泡排序法

用冒泡排序法对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个 ，那么可以把这三个字符串看成一个二维数组，这样一个一位数组的指针就可以访问该数组，然后根据冒泡排序的原理就可以排序了。

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。

所以，如果两个元素相等，是不会再交换的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。