本文目录
- 冒泡排序算法
- 编写冒泡排序算法 冒泡排序算法的分析与改进 算法设计
- 编写一个双向冒泡排序算法，即在排序过程中交替改变扫描方向题目要求：数据从数组的0单元放起
- c语言生成50个随机数,对随机数进行冒泡和双向冒泡排序
- c语言冒泡排序的编程
- 冒泡排序算法，java
- 修改冒泡排序法以实现双向冒泡排序即第一次把最大记录放到表尾，第二次将最小记
- 简单写一下冒泡排序算法
- 编写一个双向冒泡排序算法是什么
- 冒泡排序
冒泡排序算法
冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复以上过程，仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到最大数前的一对相邻数，将小数放前，大数放后，第二趟结束，在倒数第二个数中得到一个新的最大数。如此下去，直至最终完成排序。 由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。 用二重循环实现，外循环变量设为i，内循环变量设为j。外循环重复9次，内循环依次重复 9，8，...，1次。每次进行比较的两个元素都是与内循环j有关的，它们可以分别用a标识，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 Procedure 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 Then //交换元素// begin Temp := R := 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){ //小的总是往前排 bubble = array array; array = 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 ) }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; for(int i=0;i《LEN;i++)nArray=LEN-i; cout《《"原始数据为："《《endl; for(int i=0;i《LEN;i++)cout《《nArray《《" "; cout《《endl; //开始冒泡 { int temp; for(int i=LEN-1;i》0;i--) for(int j=0;j《i;j++) { if(nArray) { temp=nArray; nArray; nArray=temp; } } } //结束冒泡 cout《《"排序结果:"《《endl; for(int i=0;i《LEN;i++)cout《《nArray《《" "; return 0; }
编写冒泡排序算法 冒泡排序算法的分析与改进 算法设计
冒泡排序算法的分析与改进 孙伟 （安徽中医学院 医药信息工程学院 09医软一班，安徽合肥，230009） 摘 要： 冒泡排序算法有两个优点：1“编程复杂度”很低，很容易写出代码；2. 具有稳定性，这里的稳定性是指原序列中相同元素的相对顺序仍然保持到排序后的序列，但当需要排序的数据较多且无序时，冒泡排序算法的时间复杂度较大，比较次数较多，本文提出了一种冒泡排序算法的改进方法，可以大大减少比较的次数，降低算法的时间复杂度。 关键词：交换排序 扫描 稳定 算法 中图分类号：TU 411.01 文献标识码：A Bubble sort algorithm analysis and improvement SUN Wei (Anhui University of Traditional Chinese Medicine Medical Information Engineering, Hefei 230009, China ；) Abstract: Bubble sort algorithm has two advantages:1 “Programming complexity”is very low，and it is easy to write code;2.It has the stability, the stability refers to the original sequence in the same element relative sequence remains to sort sequence, but when the need to sort the data and more disordered, bubble sort algorithm time complexity compared to larger, more often, this paper presents a bubble sort algorithm method, can greatly reduce the number of comparisons, reduce the time complexity of algorithm. Key words：Exchange sort ; Scanning ; stability ; Algorithm 1. 概述 1.1 冒泡排序简介 冒泡排序法是一种交换排序法，这种方法的基本思想是，将待排序 的元素看作是竖着排列的“ 气泡”，较小的元素比较轻，从而要往上浮。在冒泡排序算法中我们要对这个“ 气泡”序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。如果发现两个相邻元素的顺序不对，即“ 轻”的元素在下面，就交换它们的位置。显然，处理一遍之后，“ 最轻”的元素就浮到了最高位置；处理二遍之后，“ 次轻”的元素就浮到了次高位置。在作第二遍处理时，由于 最高位置上的元素已是“ 最轻”元素，所以不必检查。一般地，第i 遍处理时，不必检查第i 高位置以上的元素，因为经过前面i- 1遍的处理，它们已正确地排好序。 1.2 冒泡排序方法 冒泡排序法是一种最简单的排序算法, 它和气泡从水中往上冒的情况有些类似。其基本算法如下：对1 至n 个记录，先将第n 个和第n- 1 个记录的键值进行比较，如r .key ——————————————————————————————————————————————————————— 收稿日期：2012-4-14； 作者简介：孙伟 1992-10-04 女 09713033 09医软一班 实现的功能：将键值最小的记录传到了第1 位。然后，再对2 至n 个记录进行同样操作，则具有次小键值的记录被安置在第2 位上。重复以上过程， 每次的移动都向最终排序的目标前进，直至没有记录需要交换为止。具体实现时，可以用一支旗子flag 表示第i 趟是否出现交换。如果第i 趟没有交换，则表示此时已完成排序，因而可以终止。 1.3 冒泡排序过程示例 设待排序的键值为： 25 17 65 13 94 47 41 94 执行冒泡排序的过程如下图所示。其中，第一列为初始键值序列, 第二列至第八列依次为各趟排序的结果， 图中用方括号括起来的是当前待排序的无序区。 每一次排序都使有序区扩充了一个气泡，在经过i 次排序之后，有序区中就有i 个气泡， 而无序区中气泡的重量总是大于等于有序区中气泡的重量，整个冒泡排序过程至多需要进行n- 1 次排序。但是, 若在某一次排序中未发现气泡位置的交换， 则说明待排序的无序区中所有气泡均满足轻者在上，重者在下的原则因此冒泡排序过程可在此次排序后终止。在上图的示例中，在第四次(图中第五列) 排序过程中就没有气泡交换位置, 此时整个文件已达到有序状态。为此，实际给出的算法中， 我们可以引入一个布尔量flag ， 在每一次排序之前， 先将它置为true ，若在一次排序中交换了记录, 则将它置为false 。当一次排序结束时，我们再检查flag ，若未曾交换过记录便终止算法。 该算法的时间复杂性为0(n2), 算法为稳定的排序方法。 2. 对于冒泡算法的改进 2.1 第一种改进方法 如果在某一趟循环中没有任何数据交换发生， 则表明数据已经排序完毕。那么剩余的循环就不需要再执行假设需要排序的数据已经按照从小到大排列，那么第一趟比较就不会有任何数据交换发生。这种改进算法如下： 设置一个标志位，当没有交换的时候这个标志位不会变化，那么说明数据已经排序好了，就不需要再进行剩余的循环。只有在标志位被重新设置的情况下才会进行剩余的循环。 public static void ImproveBubble1(int myArray) { bool isSorted = false; for(int i = 0; i // 只有在没有排序的情况下才继续循环 { isSorted = true; // 设定排序标志 for(int j = 0; j myArray ) { isSorted = false; // 如果是没有排序，就重新设定标志 Swap(refmyArray, refmyArray); } } } } 从这种算法可以看出，若记录的初始状态是正序（ 从小到大） 的，则一趟扫描即可完成排序。所需的较和记录移动的次数分别达到最小值n- 1 和0。即算法最好的时间复杂度为0(n)；若初始记录是反序（ 从大到小） 的，则需要进行n- 1 趟排序，每趟排序要进行n- i 次关键字的比较，且每次比较都必须移记录三次来达到交换记录位置。在这情况下比较和移动次数达到最大值：比较次数：Cmax= n(n- 1)/2 移动次数： Mmax=3n(n- 1)/2因此这种改进方法的最坏时间复杂度也为0(n^2)。在平均情况下，算法可能在中间的某一趟排序完后就终止，但总的比较次数仍为0(n^2)，所以算法的 平均时间复杂度为0(n^2)。因此，这种算法最好的时间复杂度为0(n)。平均，最坏时刻复杂度为0(n^2)。 2.2 第二种改进方法 在冒泡排序的每趟扫描中， 记住最后一次交换发生的位置lastexchange 也能有所帮助。因为该位置之前的相邻记录已经有序，故下一趟排序开始的时候，0 到lastexchange 已经是有序的了，lastexchange 到n- 1是无序区。所以一趟排序可能使当前有序区扩充多个记录。即较大缩小无序区范围，而非递减1，以此减少排序趟数。这种算法如下： 在冒泡排序中，每趟排序实现了将最大(升序) 或最小(降序) 的记录安置到未排序部分的最后位置，即最终位置。通过进一步观察研究，由于每趟排序过程中，通过和邻记录关键字两两比较，大(升序) 或小(降序) 的记录在不断地往下沉或往后靠，小(升序) 或大(降序) 的记录在不断往上冒或往前靠。每经过一趟排序，在最后次交换位置后面的记录都已经排好序。根据上面的思路，对n 个记录进行第k 趟排序，首先需在第k- 1 趟排序时记下最后交换的位置。然后在第k 趟排序时，将第一个记录的关键字与第二个记录的关键字进行比较，符合交换条件时，进行交换。再比较第二个记录和第三个记录的关键字，依次类推，直至第m- 1 个记录和第m 个记录的关键字进行比较，而不需要比较至n- k- 1 个记录。在大部分排序中，m 都小于n- k- 1从而减少了比较趟数和每趟的比较次数。由于在第一趟排序 时，没有上一趟排序的m 值。因此，还要设置m 的初始值为n- 1。 public static void ImproveBubble2(intmyArray) { int m= myArray.Length -1; int k, j; while(m》 0 ) { for( k=j=0; j myArray) { Swap(refmyArray); k = j; // 记录每次交换的位置 }} m= k; // 记录最后一个交换的位置 }} 从这种算法可以看出，若记录的初始状态是正序（ 从小到大） 的。则一趟扫描即可完成排序， 所的关键比较和记录移动的次数分别达到最小值n- 1 和0。即算法最好的时间复杂度为0(n);若初始记录是反序（ 从大到小） 的，则需要进行n- 1 趟排序，每趟排序要进行n- i 次关键字的比较，且每次比较都须移动记录三次来达到交换记录位置。在这情况下比较和移动次数达到最大值：比较次数：Cmax= n(n- 1)/2 移动次数Mmax=3n(n- 1)/2因此，这种办法的最坏时间复杂度也为0(n^2)。在平均情况下，算法较大地改变了无序区的范围，从而减少了比较的次数，但总的比较次数仍为0(n^2)。所以算法的平均时间复杂度为0(n^2)。因此，算法2 最好的时间复杂度为0(n)。平均，最坏时刻复杂度为0(n^2)。 2.3 双向扫描冒泡法 若记录的初始状态为:只有最轻的气泡位于d位置) ，其余的气泡均已排好序。在上述三种算法中都要做n- 1 趟扫描。实际上只需一趟扫描就可以完成排序。所以对于这种不 对称的情况。可对冒泡排序又作一次改进。在排序过程中交替改变扫描方向。即先从下扫到上，再从上扫到下，来回地进行扫描，这样就得到双向冒泡排序算法。 对n 个记录进行排序时，设up 记录了从前面向后面依次进行扫描时最后的交换位置，low 记录了从后面向前面依次进行扫描时最前的交换位置。由上个改进的冒泡排序的原理可知，up 后面的记录和low 前面的记录都已有序。每趟排序都由两次不同方向的比较、交换组成。第一次是从未排好序的第一个记录开始，即从low 记录开始，向后依次两两比较，如果不符合条件，则交换之， 直至比较到未排好序的最后一个记录，即up 记录为止。同时记下最后一次交换的位置，并存于up 。第二次是从未排好序的最后一个记录开始, 即从up 记录开始，向前依次两两比较，如果不符合条件，则交换之，直至比较到未排好序的第一个记 录，即low 记录为止。同时记下最后次交换的位置，并存于low 。这样，就完成了一趟排序。每趟排序都实现了将未排好序部分的关键字大的记录往后移 (升序) ， 关键字小的记录往前移（ 升序) ，从而使 两端已排好序（ 如果是降序，记录移动的方向则相反) 。未排好序部分的记录的首尾位置分别由low 和up 指明。不断按上面的方法进行排序，使两端已排好序的记录不断增多，未排好序部分的记录逐渐减少。即low 和up 的值不断接近，当low》=up 时，表明已没有未排好序的记录，排序就完成了。由于在第一趟排序时，没有上趟排序的low 和up 值。因此，还要设置low 和up 的初始值分别为0 和n- 1。 public static void ImproveBubble3(int myArray) { int low, up, index, i; low= 0; up = myArray.Length - 1; index = low; while( up 》 low) { for( i=low; imyArray) { Swap(refmyArray, refmyArray); index = i; }} up= index; // 记录最后一个交换的位置 for(i=up; i》low; i- - ) // 从最后一个交换 位置处从下向上扫描 { if(myArray Swap(refmyArray, refmyArray); index = i; }} low= index; // 记录最后一个交换的位 置 }} 从这种算法可以看出，若记录的初始状态是正 序（ 从小到大） 的，则一趟扫描即可完成排序。所需的关键比较和记录移动的次数分别达到最小值n- 1 和0。即算法最好的时间复杂度为0(n);若初始记录是反序（ 从大到小） 的，则需要进行趟排序。如果只有最重的气泡在最上面（ 或者最轻的气泡在最下面） ，其余的有序，这时候就只需要比较1 趟。但是在最坏的情况下，算法的复杂度也为0(n^2)。因此，算法最好的时间复杂度为0(n)，最坏时刻复杂度为0(n^2)。 3. 性能分析 为了分析数据两种冒泡排序法的性能， 我们用自编的测试程序对大量数据进行了测试，得出下表，从表中可以直观地看出两种冒泡排序方法的性能差异（ 时间单位为毫秒）。 图1 算法运行时间比较表 4. 结束语 从上面的表格可以看出，在数据量比较小的时候，这几种算法基本没有任何区别。当数据量比较大的时候，双向扫描冒泡排序会有更好的效率。但是效率并没有根本的提升。因此冒泡排序确实不是我们排序的首选。在数据量比较大的时候，快速排序等会有非常明显的优势。但是在数据量很小的时候，各种排序算法的效率差别并不是很大。那么冒泡排序也会有自己的用武之地。因此，在实际考虑算法的时候，最重要的是熟悉各种算法的性能表现并且根据数据的数量以及当前运行的环境，开发的进度选择最合适的算法。 ［1］（ 美） 莱维丁著. 潘彦译，《算法设计与分析基础》. 清华大学出版社 ［2］ 胡金初，《计算机算法》. 清华大学出版社 ［3］ 阿苏外耶（M．H．Alsuwaiyel），朱洪（译），《算法设计技巧与分析》．电子工业出版社 ［4］（美）Robert sedgewick，《算法分析导论》．机械工业出版社 ［5］（ 美）Michael T．Goodrich Roberto Tamassia，《算法分析与设计》人民邮电出版社 ［6］王晓东，《计算机算法设计与分析》电子工业出版社 ［7］Shaffer，Clifford，张铭，《数据结构与算法分析》电子工业出版社 ［8］刘任任 ，《算法设计与分析》武汉理工大学出版社，2003
编写一个双向冒泡排序算法，即在排序过程中交替改变扫描方向题目要求：数据从数组的0单元放起
【答案】：void dbubble(RECORDNODE*r，int n){ int i,j;RECORDNODE temp;int ex=1;i=0;while(ex){ ex=0;for(j=n-i-1;j＞i;j--)if(r.key){ ex=1;temp=r;r;r=temp;}for(j=i+1;j＜n-i-1;j++)if(r.key){ ex=1;temp=r;r;r=temp;}i++;}}
c语言生成50个随机数,对随机数进行冒泡和双向冒泡排序
冒泡法进行升序排序，双向冒泡法进行降序排序。
#include 《stdio.h》#include 《stdlib.h》void rndData(int data, int length){int i;for(i=0;i《length;i++){data}}void printData(int data, int length){int i;for(i=0;i《length;i++){printf("%4d", data);if((i+1)%10 == 0){printf("\n");}}printf("\n");}void swap(int *a, int *b){int temp;temp = *a;*a = *b;*b = temp;}void bubbleSort(int data, int length){int i,j=length;while(j》0){for(i=0;i《j-1;i++){if(data){swap(&data);}}j--;}}void shakerBubbleSort(int data, int length){int left = 0, right = length - 1;int i,j;while(right 》 left){for(i=left;i《right;i++){if(data){swap(&data);j = i;}}right = j;for(i=right-1;i》=left;i--){if(data){swap(&data);j = i + 1;}}left = j;}}void main(){int data;srand(time(0));//rand data and sort ascrndData(data, 50);printData(data, 50);bubbleSort(data, 50);printData(data, 50);//sort des//rndData(data, 50);//printData(data, 50);shakerBubbleSort(data, 50);printData(data, 50);}
c语言冒泡排序的编程
#include 《stdio.h》void sort(int *a,int len){int i=0;int j;int t;for(i=0;i《len-1;i++) {for(j=0;j《len-i-1;j++){if(a){t=a;a;a=t;}}}}int main(int argc, char *argv){int a={-999,2,3,77,12,88,0,-8,99,100};int i=0;sort(a,10);for(i=0;i《10;i++){printf(%d ,a);}return 0;}冒泡算法冒泡排序的算法分析与改进 交换排序的基本思想是：两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。 应用交换排序基本思想的主要排序方法有：冒泡排序和快速排序。冒泡排序 1、排序方法 将被排序的记录数组R变为新的有序区。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； exchange=TRUE； //发生了交换，故将交换标志置为真 } if(!exchange) //本趟排序未发生交换，提前终止算法 return； } //endfor(外循环) } //BubbleSort4、算法分析 （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的位置，其余的气泡均已排好序，那么也只需一趟扫描就可以完成排序。【例】对初始关键字序列12，18，42，44，45，67，94，10就仅需一趟扫描。 需要n-1趟扫描完成排序情况： 当只有最重的气泡位于R的位置，其余的气泡均已排好序时，则仍需做n-1趟扫描才能完成排序。【例】对初始关键字序列：94，10，12，18，42，44，45，67就需七趟扫描。 ②造成不对称性的原因 每趟扫描仅能使最重气泡下沉一个位置，因此使位于顶端的最重气泡下沉到底部时，需做n-1趟扫描。 ③改进不对称性的方法 在排序过程中交替改变扫描方向，可改进不对称性。
冒泡排序算法，java
原理：比较两个相邻的元素，将值大的元素交换至右端。思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至全部排序完成。publicclass BubbleSort { publicstaticvoid main(String arr={12,45,23,67,56,34,99,123}; System.out.println("排序前数组为："); for(int n:arr){ System.out.print(n+""); } for(int i=0;i《arr.length-1;i++){//外层循环控制排序趟数 for(int j=0;j《arr.length-1-i;j++){//内层循环控制每一趟排序多少次 if(arr=temp; } }
修改冒泡排序法以实现双向冒泡排序即第一次把最大记录放到表尾，第二次将最小记
冒泡排序法比较简单啊~~~给你个算法：一组数据用数组储存，无论你是自己初始化也好，还是随机产生也好；如：int{1, 2, 6, 4, 7, 3};int;Random rand = new Random();for(int i = 0; i 《 number.length; i ++){ number = rand.next(0, 10000);}然后从数组的第一个数开始与其相领的数据进行比较，你要大的数据用小于号，比较小的数据就用大于号，如下：for(int m = 0; m 《 number.length; m ++){ for(int n = 0; n 《 number.length - 1; n ++) { if(number)//如果小于就交换数据 { int t = number; number; number = t; } /*最小排序 if(number)//如果大于就交换数据 { int t = number; number; number = t; } */ }}最后输出我就不说了，做了循环就可以了~~
简单写一下冒泡排序算法
具体如下。冒泡排序原理：比较相邻两元素，将值大的交换到右边（从小到大排序，也可从大到小排序）；步骤：第一趟第一次比较：首先比较第一和第二个数，将小数放在前面，将大数放在后面。比较第2和第3个数，将小数放在前面，大数放在后面。重复步骤(2)，直到比较到最后的两个数，将小数放在前面，大数放在后面，第一趟排序完成。冒泡排序（BubbleSort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
编写一个双向冒泡排序算法是什么
解：实现本题功能的算法如下：\x0d\x0a void dbubblesort(sqlist r,int n)\x0d\x0a {\x0d\x0a int i,j,flag;\x0d\x0a flag=1;\x0d\x0a i=1;\x0d\x0a while(flag!=0)\x0d\x0a {\x0d\x0a flag=0;\x0d\x0a for(j=i;j
冒泡排序
冒泡排序（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){ exchange= list; list; list=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 a=list; list; list=a; } } } } } 虽然实现的目标是相同的，但是实现的原理也一样 只不过流程是逆向的 完成之后便是如此 如果使用Stiring 字符串的compareTo 也可以是实现类似功能 不过这个比较的是字符串的ASCII码值的大小 ，可以应用于数字字符串的比较， 如此冒泡依旧可以使用。 //实现字符串的冒泡 public static 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)《0 ){ a=list; list; list=a; } } } } return list; }
