冒泡排序

冒泡排序主要思想：两两比较待排序的关键字，并交换不满足次序要求的那对数，直到整个表都满足次序要求为止。 例如升序：就是将每个数字与其第二个数字进行比较，如果签个数字大于后一个则两个数字交换位置 java package com.rs; public class Test { public static void main(String[] args) { int[] arr = {3,2,5,6,2,7,10,9}; for (int i = 0; i < arr.length; i++) { for (int j = i+1; j < arr.length; j++) { int tmp; if (arr[i]>arr[j]) { tmp = arr[j]; arr[j] = arr[i]; arr[i] = tmp; } } } for (int i = 0; i < arr.length; i++) { System.out.print(arr[i]); } } } python（加入一个bchange，如果第一此已经是正序或者反序，则不需要进行排序） def bubbleSort(input_list): if len(input_list) == 0: return [] sorted_list = input_list for i in range(len(sorted

基本思想： 在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。（或者是小的数字下沉，大的上冒） java实现： public class SortTest { private static int[] bubbleSort(int[] args){ int temp = 0; for(int i = 0; i < args.length; i++){ for(int j = 0; j < args.length - 1; j++){ if(args[i] < args[j]){ temp = args[j]; args[j] = args[i]; args[i] = temp; } } } return args; } public static void main(String[] args) { int[] a = {34,56,43,57,41,39,32,99,33}; int[] c = bubbleSort(a); for(int i = 0 ; i < c.length; i++){ System.out.println(c[i]); } } } 来源： oschina 链接： https://my.oschina.net

//冒泡排序 从自小到大对数组进行排序 相邻的两个数 前者大于后者则交换public class HelloWorld { public static void main(String[] args) { int myArray[]={36,13,9,76,11,5}; int len=myArray.length-1; boolean flag=false; for(int i=0;i<len;i++){ for(int j=0;j<len-i;j++){ if(myArray[j]>myArray[j+1]){ int temp=0; temp=myArray[j+1]; myArray[j+1]=myArray[j]; myArray[j]=temp; flag=true; } } if(!flag){ break; }else{ flag=false; } } for(int i=0;i<len+1;i++){ System.out.print(myArray[i]+"\t"); } }} 来源： https://www.cnblogs.com/ljywxk/p/11541037.html

https://www.cnblogs.com/kkun/archive/2011/11/23/bubble_sort.html #include<iostream> #include <stdio.h> #include <stack> using namespace std; void bubble_sort(int *a, int begin, int end) { for(int i = begin; i < end-1; i++) for (int j = i+1; j < end; j++) { if (a[i] > a[j]) { int temp = a[i]; a[i] = a[j]; a[j] = temp; } } } int main() { int a[8] = {4, 2, 6, 7, 9, 5, 1, 3}; int length = sizeof(a) / sizeof(a[0]); bubble_sort(a, 0, length); for(int i=0; i<8; i++) { cout << a[i] << " " << endl; } return 0; } 来源： https://www.cnblogs.com/pengwang52/p/11538409.html

相信接触过编程语言的同学们都会对冒泡排序不陌生,今天我为大家分享一下冒泡排序的一些实现等等 注:冒泡排序为我个人理解如若有不同意见的同学欢迎讨论 首先介绍一下楼主的思路: 假如现在有以下一个数组 楼主的思路是:用第一个数去比对其他所有的数 , 假定从小到大进行排序,那么我使用第一个数也就是 下标为0的数字45去与其他数85,65等等比较 从小到大那么下标为0的元素应该是数组中的最小值 所以当我们进行比较的时候我们通过判断大于的方式如果大于那么就交换位置就是说假如 45>85那么使用第三个变量进行交换位置,这样的话下标为0的元素就可以确定为以比较过数的最小值 然后下标为1的开始与后面的每一个数进行比较,因为下标为0的比较之后已经是最小值,那么除小标为0的元素 之后继续重复前面的步骤求出第二小的值!最后重复上面的步骤进行排序 下面上代码图 详细的步骤差不多就这样,有一点需要注意的就是这个方法是一个一个下标的进行确认排序! 好了,楼主的分享就到这里了! 感谢你的观看,尽管我写的不是很好! 来源： https://my.oschina.net/u/4191619/blog/3107137

冒泡排序是一种交换排序。 交换排序：两两比较待排序的关键字，并交换不满足次序要求的那对数，直到整个表都满足次序要求为止。 from random import shuffle lst = [i for i in range(10)] shuffle(lst) flag = False for i in range(len(lst)): for j in range(len(lst)-1-i): flag = False if lst[j] > lst[j+1]: lst[j], lst[j+1] = lst[j+1], lst[j] flag = True if not flag: break print(lst) 来源： https://www.cnblogs.com/luckyleaf/p/11531155.html

原理：每次比较两个相邻的元素，将较大的元素交换至右端。 思路：每次冒泡排序操作都会将相邻的两个元素进行比较，看是否满足大小关系要求，如果不满足，就交换这两个相邻元素的次序，一次冒泡至少让一个元素移动到它应该排列的位置，重复N次，就完成了冒泡排序。 通过一个图来简单理解一下一次冒泡的过程【注意：图中每一竖列是一次比较交换】： 图中可以看出，经过一次冒泡，6这个当前数组中最大的元素飘到了最上面，如果进行N次这样操作，那么数组中所有元素也就到飘到了它本身该在的位置，就像水泡从水中飘上来，所以叫冒泡排序。 下图就是整个飘的过程： 以上，第五第六次可以看到，其实第五次冒泡的时候，数组已经是有序的了，因此，还可以优化，即如果当次冒泡操作没有数据交换时，那么就已经达到了有序状态 代码实例： public class BubbleSort { public void bubbleSort(Integer[] arr) { int n = arr.length; if (n <= 1) return; //如果只有一个元素就不用排序了 for (int i = 0; i < n; i++) { // 提前退出冒泡循环的标志位,即一次比较中没有交换任何元素，这个数组就已经是有序的了 boolean flag = false; for (int j = 0; j < n - i - 1; j++) {

1、排序方法 将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为R[i].key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。 （1）初始 　 R[1..n]为无序区。 （2）第一趟扫描 　 从无序区底部向上依次比较相邻的两个气泡的重量，若发现轻者在下、重者在上，则交换二者的位置。即依次比较(R[n]，R[n-1])，(R[n-1]，R[n-2])，…，(R[2]，R[1])；对于每对气泡(R[j+1]，R[j])，若R[j+1].key<R[j].key，则交换R[j+1]和R[j]的内容。 　第一趟扫描完毕时，"最轻"的气泡就飘浮到该区间的顶部，即关键字最小的记录被放在最高位置R[1]上。 （3）第二趟扫描 　 扫描R[2..n]。扫描完毕时，"次轻"的气泡飘浮到R[2]的位置上…… 　最后，经过n-1 趟扫描可得到有序区R[1..n] 注意： 　 第i趟扫描时，R[1..i-1]和R[i..n]分别为当前的有序区和无序区。扫描仍是从无序区底部向上直至该区顶部。扫描完毕时，该区中最轻气泡飘浮到顶部位置R[i]上，结果是R[1..i]变为新的有序区。 2、冒泡排序过程动画演示 https://www.erdangjiade.com

排序算法是每个程序员必备的技能，最近发现自己贪图数组的sort方法，已经把排序算法遗忘的差不多了，就来整理一下。 首先是各个排序都会用到的一些方法 //交换指定索引的数组元素 function swap(arr,i,j) { [arr[i], arr[j]] = [arr[j],arr[i]]; } 冒泡排序 冒泡排序比较相邻的两个项，如果第一个比第二个大（小）就交换他们 选择排序 来源： https://blog.csdn.net/weixin_42003972/article/details/100855944

排序算法说明: （1）对于评述算法优劣术语的说明 稳定 ：如果a原本在b前面，而a=b，排序之后a仍然在b的前面； 不稳定 ：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面； 内排序 ：所有排序操作都在内存中完成； 外排序 ：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行； 时间复杂度 : 一个算法执行所耗费的时间。 空间复杂度 : 运行完一个程序所需内存的大小。 (2)排序算法图片总结: 　　 1.冒泡排序: 解析：1.比较相邻的两个元素，如果前一个比后一个大，则交换位置。 　　　2.第一轮的时候最后一个元素应该是最大的一个。 　　　3.按照步骤一的方法进行相邻两个元素的比较，这个时候由于最后一个元素已经是最大的了，所以最后一个元素不用比较。 2.快速排序: 解析：快速排序是对冒泡排序的一种改进，第一趟排序时将数据分成两部分，一部分比另一部分的所有数据都要小。然后递归调用，在两边都实行快速排序。 3.插入排序: 解析： （1） 从第一个元素开始，该元素可以认为已经被排序 （2） 取出下一个元素，在已经排序的元素序列中从后向前扫描 （3） 如果该元素（已排序）大于新元素，将该元素移到下一位置 （4） 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置 （5）将新元素插入到下一位置中 （6） 重复步骤2 　　 2.二分查找: 解析