冒泡排序原理，冒泡排序是什么

本文目录一览

1，冒泡排序是什么
2，什么是冒泡排序法
3，帮忙给理解一下这个冒泡排序法是如如何实现的从网上粘来的代码
4，怎么用冒泡排
5，冒泡排序算法
6，谁能讲一下冒泡排序原理

1，冒泡排序是什么

冒泡排序是什么

2，什么是冒泡排序法

冒泡排序（英语：Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。冒泡排序对冒泡排序是与插入排序拥有相等的运行时间，但是两种算法在需要的交换次数却很大地不同。在最坏的情况，冒泡排序需要冒泡排序算法的运作如下：比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。针对所有的元素重复以上的步骤，除了最后一个。持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。由于它的简洁，冒泡排序通常被用来对于程序设计入门的学生介绍算法的概念。

目的：按要求从大到小或从小到大排序。基本思路：对尚未排序的各元素从头到尾依次依次比较相邻的两个元素是否逆序（与欲排顺序相反），若逆序就交换这两元素，经过第一轮比较排序后便可把最大（或最小）的元素排好，然后再用同样的方法把剩下的元素逐个进行比较，就得到了你所要的顺序。可以看出如果有 n 个元素，那么一共要进行 n-1 轮比较，第 i 轮要进行 j=n-i 次比较。（如：有5个元素，则要进行5-1轮比较。第3轮则要进行5-3次比较） <a href="http://wenwen.soso.com/z/urlalertpage.e?sp=shttp%3a%2f%2fbaike.baidu.com%2fview%2f1313793.htm" target="_blank">http://baike.baidu.com/view/1313793.htm</a>

什么是冒泡排序法

3，帮忙给理解一下这个冒泡排序法是如如何实现的从网上粘来的代码

冒泡排序就是二重循环、、我是理解、、你的是什么语言。。你这代码有点高深。。我是 c# 希望对你有帮助 for (int i = 0; i < shu.length-1; i++) for (int j = 0; j <shu.length-i-1;j++ ) if(shu[j]>shu[j+1]) int tem = shu[j]; shu[j] = shu[j + 1]; shu[j + 1] = tem; } } //这就是冒泡排序的。、二重循环、、、、 }首先其实原理就是、它是一个二重循环、、外层循环控制比较多少轮、内层控制比较的次数、、int j = 0; j <shu.length-i-1;j++ 他这个条件次数随着外层的 i 而变得、、其实目的就是每外层循环一次就找出当前最大数、、放到最后、这样的话我们比较（数的个数-1）次就行了、找出一个数（一次大循环、）、控制次数减1 、然后用内循环控制shu.length-i-1 控制、、、好吧、、、就举个例子：例如：我们找5个数、23,90,9,25,16，(我们接收数据的时候下标是0,1,2,3,4)当第一个数大于第二个数时：就交换两个数、需要知道的是：每 i 循环一次、 j就循环shu.length-i-1次。。当然 i是越来越大的、、而内循环的循环次数越来越少、、的当 i=0时、j=0一开始shu[j]=23; shu[j+1]=90； (下标是0的时候第一个数)j<shu.length-i-1=5-0-1=4 ，符合条件他是不执行 if的；23,90,9,25,16这时候j++j就变成 1 了， (下标是1的时候第二个数)j<shu.length-i-1=5-0-1=4 ，符合条件这时候shu[j]=90;shu[j+1]=9它执行 if 语句、shu[j]=9;shu[j+1]=90;23,9,90,25,16这时候j++ j就变成 2 了， (下标是2的时候第三个数)j<shu.length-i-1=5-0-1=4 ，符合这时候shu[j]=90;shu[j+1]=25他还执行if 语句、这时候shu[j]=25;shu[j+1]=9023,9,25,90,16这时候j++ j就变成 3 了， (下标是3的时候第四个数)j<shu.length-i-1=5-0-1=4 ，符合这时候shu[j]=90;shu[j+1]=16他还执行if 语句、这时候shu[j]=16;shu[j+1]=9023,9,25,16,90这时候j++j<shu.length-i-1=5-0-1=4 ，不符合、、、、跳出 j 循环、23,90,9,25,1623,9,90,25,1623,9,25,90,1623,9,25,16,90i=1；找出了第二个大的、、内层的条件j<shu.length-i-1=5-1-1=3只循环 3次、、根本比较不到最后一个、、、9,23,25,16,909,23,25,16,909,23,16,25,90i=2；找出了第三个大的、、内层的条件j<shu.length-i-1=5-2-1=2只循环 2次、、9,23,16,25,909,16,23,25,90i=3；找出了第四个大的、、 i < shu.length-1=i<5-1=4; i<4内层的条件j<shu.length-i-1=5-3-1=1只循环 1次、、9,16,23,25,90 i++等于4 跳出循环、、、、、、、得理解以后、、在写代码、、、没事 debug 、、、 debug 、、、、、、、

帮忙给理解一下这个冒泡排序法是如如何实现的从网上粘来的代码

4，怎么用冒泡排

for(i=0;i<=n;i++) if(a[j+1]<=a[j]) a[j+1]=a[j]; a[j]=temp; } } }

冒泡排序法又名起泡法。冒泡排序法原理详解（一）：起泡法是从一端开始比较的，第一次循环就是把最小数上升到第一位置，第二次循环就是把第二最小数上升到第二位置。如此循环实现数据的排序。那么我们是否可以找到最小数的同时找到最大数呢？当然可以。方法是在一端起泡时同时在另一端也进行起泡。即反向起泡。下面的程序段实现的是双向起泡： void Bubble2Sort(int* pData,int Count) int iTemp; int left = 1; int right =Count -1; int t; do //正向的部分 for(int i=right;i>=left;i--) if(pData iTemp = pData; pData = pData[i-1]; pData[i-1] = iTemp; t = i; } } left = t+1; //反向的部分 for(i=left;i if(pData iTemp = pData; pData = pData[i-1]; pData[i-1] = iTemp; t = i; } } right = t-1; }while(left<=right); } 分析上面的程序段我们可以发现正向起泡时第一次循环找出了最小数，反向起泡第一次循环找到最大数。很显然在一次循环中即可以找到一个最小的数还可以找到一个最大的数，所以用双向冒泡排序的交换的次数减少了，从而达到了优化起泡法的作用。冒泡排序法原理详解（二）：首先申明，这不是教程，我只是将冒泡排序原理详细解释，希望对大家有用~~~ 冒泡法排序是一个比较简单的排序方法。在待排序的数列基本有序的情况下排序速度较快。若要排序的数有n个，则需要n-1轮排序，第j轮排序中，从第一个数开始，相邻两数比较，若不符合所要求的顺序，则交换两者的位置；直到第n+1-j个数为止，第一个数与第二个数比较，第二个数与第三个数比较，......，第n-j个与第n+1-j个比较，共比较n-1次。此时第n+1-j个位置上的数已经按要求排好，所以不参加以后的比较和交换操作。例如：第一轮排序：第一个数与第二个数进行比较，若不符合要求的顺序，则交换两者的位置，否则继续进行二个数与第三个数比较......。直到完成第n-1 个数与第n个数的比较。此时第n个位置上的数已经按要求排好，它不参与以后的比较和交换操作；第二轮排序：第一个数与第二个数进行比较，......直到完成第n-2个数与第n-1个数的比较；......第n-1轮排序：第一个数与第二个数进行比较，若符合所要求的顺序，则结束冒泡法排序；若不符合要求的顺序，则交换两者的位置，然后结束冒泡法排序。共n-1轮排序处理，第j轮进行n-j次比较和至多n-j次交换。从以上排序过程可以看出，较大的数像气泡一样向上冒，而较小的数往下沉，故称冒泡法。我给出了一个例子，大家自己看一下吧 AS为：function array_1(array) for (var n = 0; n<array.length; n++) for (var j = 0; j<array.length-n; j++) if (array[j]<array[j+1]) temp = array[j];array[j] = array[j+1];array[j+1] = temp;}}for (var k = 0; k<array.length; k++) trace(array[k]);}trace(" ");}}my_array = new Array(0, 2, 3, 9);array_1(my_array); 看了原理，AS应该没问题了，当然大家可以通过改变数组中元素以及个数来验证程序。希望对大家有帮助PS:#include<stdio.h>#include<stdlib.h>void bubblesort(int data[], int n);int main(void) int arr[10]; int i; printf("input 10 data: "); for(i = 0; i < 10; i++) scanf("%d ", &arr[i]); } bubblesort(arr, 10); for(i = 0; i < 10; i++) printf("%d ", arr[i]); } return 0;}void bubblesort(int data[], int n) int i, j, tag, temp;/* for(i = 0; tag = 1 && i < n -1; i++) tag = 0; */ for(j = 0; j < n - 1; j++) if(data[j] > data[j+1]) temp = data[j]; data[j] = data[j+1]; data[j+1] = temp; tag = 1; }/* end if */ }/*end for *//* } */}/* end bubblesort */

5，冒泡排序算法

该程序为：#include void main() int a[8]; int i,j,t; printf("请输入8个整数："); for(i=0;i<8;i++) scanf("%d",&a[i]); for(i=1;i<8;i++) for(j=1;j<=8-i;j++) if(a[j-1]>a[j]) t=a[j-1]; a[j-1]=a[j]; a[j]=t; } printf("排序后的结果："); for(i=0;i<8;i++) printf("%d \n",a[i]);}第一趟：57 78 80 27 32 90 45 100第二趟：57 78 27 32 80 45 90 100第三趟：57 27 32 78 45 80 90 100第四趟：27 32 57 45 78 80 90 100

就是像水泡一样逐个地比较然后到最上面

冒泡排序（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 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[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] //小的总是往前排 bubble = array[j] array[j] = array[j-1]; array[j-1] = bubble; } } } } io.print("----------------") io.print("冒泡排序( 交换类换排序 )") io.print("----------------") array = 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 if (*(x+j) > *(x+j+1)) /*大的放在后面，小的放到前面*/ t = *(x+j); *(x+j) = *(x+j+1); *(x+j+1) = t; /*完成交换*/ k = j; /*保存最后下沉的位置。这样k后面的都是排序排好了的。*/ } } } }c++ #include #define len 9 using namespace std; int main() int narray[len]; for(int i=0;i cout<<"原始数据为："< for(int i=0;i cout< //开始冒泡 int temp; for(int i=len-1;i>0;i--) for(int j=0;j{ if(narray[j]>narray[j+1]) { temp=narray[j]; narray[j]=narray[j+1]; narray[j+1]=temp; } } } //结束冒泡 cout<<"排序结果:"< for(int i=0;i return 0; }

6，谁能讲一下冒泡排序原理

冒泡排序算法的原理如下：1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。2.对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。3.针对所有的元素重复以上的步骤，除了最后一个。4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。扩展资料：算法优化：当里面的一层循环在某次扫描中没有交换则说明此时数组已经全部有序，无需再再次扫描。所以可以添加一个标记每交换一次就进行标记，如果某次没有没有标记就说明已经有序了写冒泡排序可以排序多个字符串。假设对4个字符串进行排序，每个字符串不超过10个，那么可以把这三个字符串看成一个二维数组，这样一个一位数组的指针就可以访问该数组，然后根据冒泡排序的原理就可以排序了。冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，是不会再交换的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。参考资料：搜狗百科——冒泡排序

『简单的来说（不高兴长篇大论了）『就是两两比较，小的靠右『从前往后，从后往前『重复N次后就排好序了。。。（就像冒气泡一样将小数“冒”上来，故曰冒泡法）

冒泡排序算法的原理如下：1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。2.对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。3.针对所有的元素重复以上的步骤，除了最后一个。4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。拓展资料：1，冒泡排序：是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名“冒泡排序”。2.算法稳定性冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

冒泡排序（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，凡扫描到违反本原则的轻气泡，就使其向上"漂浮"，如此反复进行，直至最后任何两个气泡都是轻者在上，重者在下为止。

冒泡排序算法的原理如下：1，比较相邻的元素。如果第一个比第二个大，就交换他们两个。2，对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。3，针对所有的元素重复以上的步骤，除了最后一个。4，持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。扩展资料：冒泡排序算法分析：1，时间复杂度若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数和记录移动次数均达到最小值：，。所以，冒泡排序最好的时间复杂度为。　　若初始文件是反序的，需要进行趟排序。每趟排序要进行次关键字的比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：冒泡排序的最坏时间复杂度为。综上，因此冒泡排序总的平均时间复杂度为。2，算法稳定性：冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，是不会再交换的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。参考资料：搜狗百科----冒泡排序