冒泡排序

排序是将一组数据，依指定的顺序进行排列的过程。 排序的分类： 1）内部排序： 　　指将需要处理的所有数据都加载到内部存储器中进行排序。 　　包括（交换式排序法、选择式排序法和插入式排序法）； 2）外部排序法： 　　数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。 　　包括（合并排序法和直接合并排序法） 交换式排序法： 交换式排序属于内部排序法，是运用数据值比较后，依判断规则对数据位置进行交换，以达到排序的目的。 交换式排序法又可分为两种： 　　1）冒泡排序法 (Bubble sort ) 　　2）快速排序法 (Quick sort) 交换式排序法--冒泡排序法 　　冒泡排序(Bubble Sorting) 的基本思想是：通过对待排序序列从后向前（从下标较大的元素开始），比较相邻元素的排序码，若发现逆序则交换，使排序码较小的元素逐渐从后部移向前部（从下标较大的单元移向下标较小的单元），就象水底下的气泡一样逐渐向上冒。 　　因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较。（优化） 下图演示了一个冒泡过程的例子： 总结冒泡排序的规则： 　　1、一共会经过 arr.length-1次的轮数比较，每一轮将会缺点一个数的位置。 　　2

1.冒泡排序：它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 原理如下： 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 算法稳定性： 冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，是不会再交换的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。 代码实现 private static void bubble(int []array){ int size = array.length; int temp = 0; for (int i =0;i<size;i++){ //外部循环的次数 for (int j =0;j<size-1-i;j++){ if (array[j]>array[j+1]){ temp = array

　　#include<stdio.h> void BubbleSort(int *Array,int Length) { int i= 0,j = 0,temp = 0; for(i = 0; i < Length - 1; i++) { for(j = 0; j < Length-i-1; j++) { 　　if(Array[j] > Array[j+1]) 　　{ 　　 temp = Array[j]; 　　 Array[j] = Array[j+1]; 　　 Array[j+1] = temp; 　　} } } } int main(void) { int i = 0; int ArrayBuf[5] = {2,1,0,4,3}; BubbleSort(&ArrayBuf[0],sizeof(ArrayBuf)/sizeof(int)); for(i = 0; i <( sizeof(ArrayBuf)/sizeof(int));i++) { printf("%d ",ArrayBuf[i]); } } 来源： https://www.cnblogs.com/HMM0530/p/11398683.html

sort() { let arr = [12, 5, 2, 1, 3, 6476, 4, 8, 47, 5644, 51]; let temp = ""; let count = 0; for (let i = 0; i < arr.length - 1; i++) { //有N个数只需要进行N-1次循环比较 let flag = true;//定义flag作为判断，减少循环次数如果第二个for循环已经比较完所有 的数让flag为false for (let j = 0; j < arr.length - i - 1; j++) {// 减 i 的原因是每次循环之后都会将最大数置最有内部循环比较不需要再与最后一个数进行比较 if (arr[j] > arr[j + 1]) { temp = arr[j + 1]; arr[j + 1] = arr[j]; arr[j] = temp; flag = false; } count++; } if (flag) { break; } console.log(arr); console.log(count); } } 来源： https://blog.csdn.net/qq_43220086/article/details/100007896

冒泡排序static int[]a=new int[]{32,2,2424,21,46,46446,34,21};static void maoPao(int[]b){ for (int i = 0; i < b.length-1; i++) { for (int j = 0; j < b.length-1-i; j++) { if (b[j+1]<b[j]){ int tem=b[j+1]; b[j+1]=b[j]; b[j]=tem; } } } for (int i:b){ System.out.print(i+"\t"); }} 来源： https://www.cnblogs.com/miaopasi-lianjiang/p/11390516.html

<!-- 冒泡排序：把一组数列按照一定的顺序进行排列，从大到小，或者从小到大 --> // 控制循环的轮数 arr = [3,14,55,2,1,4,5] for(var i=0; i<arr.length-1;i++){ // 控制每轮循环对比的次数 for(var j=0;j<arr.length-1-i;j++){ if(arr[j]>arr[j+1]){ var temp=arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } 假设有4个数 // 4 3 2 1 // 第一轮 3 2 1 4 比较次数 3 （arr.length-1-0) 0就是i 数组长4 // 第二轮 2 1 3 1 比较次数 2 （arr.length-1-1) // 第三轮 1 2 3 4 比较次数 1 （arr.length-1-2) 来源： http://www.cnblogs.com/zyt6688/p/9193862.html

1.冒泡排序 冒泡排序是一种比较简单的排序算法。算法的原理是： 重复地走访过要排序的数列，一次比较相邻的两个元素，按照规定好的顺序进行比较，如果他们的顺序错误就把他们交换过来。走访数列的工作重复的进行直到没有再需要交换的元素，此时数列的排序已经完成。 核心代码： 1 private static void bubbleSortTest(int arr[]) { 2 int temp = 0; 3 for (int i = 0; i < arr.length-1; i++) { 4 for (int j = arr.length-1; j > i; j--) { 5 if (arr[j-1] > arr[j]) { 6 temp = arr[j-1]; 7 arr[j-1] = arr[j]; 8 arr[j] = temp; 9 } 10 } 11 } 12 } 以上代码完成的工作是采用冒泡排序从小到大排列一个数组。 在外循环中从前往后读数组，然后在内循环中从后往前比较，相邻的数进行两两比较，若前一个数比它相邻的后一个大，则交换他们的位置。每次外循环一次都把第i小的元素移到了arr[i]的位置，所以内循环中的条件是j>i，因为arr[i]前面的都排好了序。每次从后往前比较时，到了arr[i]就不用再继续了。 当然，上面的核心代码也可以写成以下这种形式： 1 private

将8，4，3，1，4，6，等数字按照从小到大的顺序依次输出； var arr=new Array(); arr.push(8); arr.push(4); arr.push(3); arr.push(1); arr.push(5); arr.push(6); var temp; for(var i=0; i<arr.length;i++) { for(var j=i+1;j<arr.length;j++) { if(arr[i]>arr[j]) { temp=arr[i]; arr[i]=arr[j]; arr[j]=temp; } } } for(var x in arr ) { alert(arr[x]); } 本题思路如下：将每个数字都放到数组里，然后将数组的每个数字取值，依次和后面的数字将比较，如果后面的数字大，那顺序不变，相反那就将后面的数字和前面的数字交换位置； 这里就需要一个交换赋值：temp; 注意：数组里的每一个数字和它后面的数字比较！！！，在最后插入一个针，将排列好的数组输出。 来源： http://www.cnblogs.com/axj1993/p/6233459.html

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。 图示: 动图演示： c++代码实现： #include<iostream> #include<cstdio> using namespace std; int bu_sort(int A[],int n) { for(int i=0;i<n;i++) { for(int j=0;j<n-1;j++) { if(A[j]>A[j+1]) swap(A[j],A[j+1]); } } } int main() { int A[]={0,2,3,46,5,3,43,4}; bu_sort(A,8); for(int i=0;i<8;i++) cout<<A[i]<<" "; } 来源： https://www.cnblogs.com/zhoubo123/p/11384088.html

　　继上次写直接插入排序，有一段时间了，现在再写上冒泡排序，该排序算法，容易记忆，在小规模的场景中 应用比较广泛，一旦需要解决的问题规模变大，该排序算法的效率明显降低因为该算法的时间复杂度为ο(n 2 )所以 选择冒泡排序的时候需要慎重考虑问题的规模。其实冒泡排序可以用一个公式总结：如果有N个数需要排序，首先 考虑两重循环外层循环for(int i=0;i<N-1;i++)，内层循环for(int j=0;j<N-i-1;j++)，即内层循环数=N-外层循环计数-1 1 #include <string> 2 #include<iostream> 3 4 #define SWAP(X,Y) X=X+Y;Y=X-Y;X=X-Y 5 6 using namespace std; 7 8 9 10 void bubble(int a[],int len); //统计value中"1"的个数 11 void print(int a[], int len); 12 13 int main(int argc, char *argv) { 14 15 int a[] = {1,2,3,4,5,6,7,8,9,10}; 16 printf("before sort:\n"); 17 print(a,10); 18 19 bubble(a, 10); 20 printf("after sort:\n