冒泡排序

编程里算法有很多，排序的算法也多种（冒泡算法、选择排序、插入排序、希尔排序、归并排序、快速排序、桶排序），各种排序也都有优缺点，特此分享出我的学习笔记，希望大家一起来学习探讨 冒泡算法思想 每次比较两个相邻的元素，如果它们的顺序错误就把它们交换过来,重复进行多次，直到没有相邻元素需要交换为止。 JAVA代码示例 package demo; /** * 冒泡排序：每次比较两个相邻的元素，如果它们的顺序错误就把它们交换过来, * 重复进行多次，直到没有相邻元素需要交换为止 * @Author LQY * @Date 2020/2/2 */ public class BubblingSort { public static void main(String[] args) { demo1(); } /** * 案例1 * 将13,20,25,25,35,34.5,12,22,100用冒泡排序从大到小排序输出 */ public static void demo1(){ //先创建一个一维数组存放无序的数字 Double[] arg = new Double[]{13d,20d,25d,25d,35d,34.5d,12d,22d,100d}; //排序前结果 System.out.println("===========排序前结果================"); for (int i

算法步骤 从第一个数开始，依次前一个数与后一个数比较大小，当后一个数比前一个数小时，两个数交换 当第n-1个数与第n个数比较完后，停止比较 再从第一个数开始，重复以上步骤 直到所有数按从小到大的顺序排列 图解算法 代码实现 ls = [ 3 , 5 , 15 , 26 , 36 , 38 , 46 , 44 , 2 , ] def bubble_sort ( ls ) : for i in range ( len ( ls ) ) : for j in range ( len ( ls ) - 1 ) : if ls [ j ] > ls [ j + 1 ] : ls [ j ] , ls [ j + 1 ] = ls [ j + 1 ] , ls [ j ] else : pass return ls ls_result = bubble_sort ( ls ) print ( ls_result ) #[2,3,5,15,26,36,38,44,46] 来源： CSDN 作者： 98* 链接： https://blog.csdn.net/stunning98/article/details/104149888

交换排序 基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置。交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。 冒泡排序 void Swap ( int * x , int * y ) { int tmp = * x ; * x = * y ; * y = tmp ; } void BubbleSort ( int * a , int n ) { int end = n ; //共n-1趟比较 while ( end > 1 ) { for ( int i = 1 ; i < end ; i ++ ) { if ( a [ i ] < a [ i - 1 ] ) { Swap ( & a [ i ] , & a [ i - 1 ] ) ; } } end -- ; } } 冒泡排序的特性总结： 1、时间复杂度：O(N^2) 2、空间复杂度：O(1) 3、稳定性：稳定 来源： CSDN 作者： ZD_012 链接： https://blog.csdn.net/ZD_012/article/details/104145300

// int array[] = {3, 2, 6, 9, 8, 5, 7, 1, 4}; // int count = sizeof(array) / sizeof(array[0]); // int flag = 1; // for (int i = 0; i < count - 1 && flag == 1; i++) { // flag = 0; // for (int j = 0; j < count - i - 1; j++) { // if (array[j] > array[j + 1]) { // int temp = array[j]; // array[j] = array[j + 1]; // array[j + 1] = temp; // flag = 1; // } // } // } // for (int i = 0; i < count; i++) { // printf("array[%d] = %d\n", i, array[i]); // } 来源： https://www.cnblogs.com/yuanview/p/3920722.html

冒泡排序（Bubble Sort） 列表每两个相邻的数，如果前面比后面大，则交换这两个数。 一趟排序完成后，则无序区减少一个数，有序区增加一个数。 public void BubbleSort(List<int> li) { for (int i = 0; i < li.Count-1; i++)//i 第几趟 { for (int j = 0; j < li.Count -i- 1; j++)//j当前指向元素 { if (li[j] > li[j + 1])//交换 { int tmp = li[j]; li[j] = li[j + 1]; li[j+1] =tmp; } } } } 冒泡排序还可以优化 也就是在针对部分有序列表，减少排序次数，比如对于 { 1, 5, 3, 4, 6, 7 }，明显不需要n-1次 只需要在每趟开始时加入一个标志位，如果发生交换就改变，每趟结束时查看标志位，如果不变，说明全程无交换，即当前列表已经是有序列表，结束。 public void BubbleSort(List<int> li) { for (int i = 0; i < li.Count-1; i++)//i 第几趟 { bool exchange = false; for (int j = 0; j < li.Count -i- 1; j++)//j当前指向元素 { if (li[j

下面首先介绍冒泡排序的基本思想，其次用Java实现冒泡排序，实现将数组元素从小到大排列。 一、冒泡排序的基本思想 1、第一轮从数组的第一个数开始，相邻的两个数之间进行比较，如果左边的数比右边大，则两个数交换顺序，否则不交换顺序；下面从数组的第二个数开始，相邻的两个数之间进行同样的比较，直到倒数第二个数和最后一个数比较完，第一轮交换结束。 经过第一轮交换，数组最大的数在数组的最后一个位置。 2、第二轮从第一个数开始，一直到倒数第二个数，以相同的方式进行交换。 3、冒泡排序的终止条件：当该轮排序没有数字之间的交换，说明该数组已经完全有序，此时冒泡排序结束。 二、冒泡排序的时间复杂度 1、数字的比较：第一轮需要n - 1次数字的比较，第二轮需要n - 2次数字的比较，以此类推，第n - 1轮需要1次数字之间的比较。 2、元素的交换：每次交换需要执行3条语句。 比如需要排序的数组为arr，arr[j + 1]和arr[j]进行交换，则要执行以下三条语句： // An highlighted block int temp = arr [ j + 1 ] ; arr [ j + 1 ] = arr [ j ] ; arr [ j ] = temp ; 3、时间复杂度为： 4 ∗ ( ( n − 1 ) + ( n − 2 ) + . . . + 1 ) ) = O ( n 2 ) 4 * (

文章目录 6.1. 冒泡排序 冒泡排序 冒泡排序的分析 时间复杂度 冒泡排序的演示 6.1. 冒泡排序 冒泡排序 冒泡排序 （英语：Bubble Sort）是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 冒泡排序算法的运作如下： 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 冒泡排序的分析 交换过程图示(第一次)： 那么我们需要进行n-1次冒泡过程，每次对应的比较次数如下图所示： def bubble_sort ( alist ) : for j in range ( len ( alist ) - 1 , 0 , - 1 ) : # j表示每次遍历需要比较的次数，是逐渐减小的 for i in range ( j ) : if alist [ i ] > alist [ i + 1 ] : alist [ i ] , alist [ i + 1 ] =

【 前言 】 小编今天来讲讲VB中的“冒泡排序”！ 【 正文 】 <**含义**> 冒泡排序（Bubble Sort），是一种 计算机科学 领域的较简单的 排序算法 ； 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。 <**原理**> 1. 大数沉底，小数上浮（ 相反亦可）； 2.参加比较的两个元素是 相临 的，每轮比较可以找出 一个本轮最大放在本轮最后，使所有小数前移位置； 3.依次类推，每一趟比较次数减少依次； 4.相等的值不进行交换，这种排序方式是 稳定的 排序方式。 <**举例**> [5，6，3，1，8，7，2，4] 1.第一趟排序： 第一次排序：5和6比较，5小于6，不交换位置 [5，6，3，1，8，7，2，4] 第二次排序：6和3比较，6大于3，交换位置 [5，3，6，1，8，7，2，4] 第三次排序：6和1比较，6大于1，交换位置 [ 5，3，1，6，8，7，2，4] 第四次排序：6和8比较，6小于8，不交换位置 [5，3，1，6，8，7，2，4] 第五次排序：8和7比较，8大于7，交换位置 [5，3，1，6，7，8，2，4] 第六次排序：8和2比较，7大于2，交换位置 [5，3，1，6，7，2，8，4] 第七次排序：8和4比较，8大于4，交换位置 [5，3

冒泡排序…… while循环判断循环次数 list = [ 4165 , 2315 , 2165 , 2123 , 565 , 89 , 56 , 56 , 23 , 6 , 5 , 1 ] num = 1 while num < len ( list ) : for i in range ( len ( list ) - 1 ) : if list [ i ] > list [ i + 1 ] : list [ i ] , list [ i + 1 ] = list [ i + 1 ] , list [ i ] num += 1 print ( list ) for循环给出循环次数 list = [ 4165 , 2315 , 2165 , 2123 , 565 , 89 , 56 , 56 , 23 , 6 , 5 , 1 ] for i in range ( len ( list ) - 1 ) : for i in range ( len ( list ) - 1 ) : if list [ i ] > list [ i + 1 ] : list [ i ] , list [ i + 1 ] = list [ i + 1 ] , list [ i ] print ( list ) 来源： CSDN 作者： 默金…… 链接： https://blog.csdn.net/qq

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。 def bubbleSort(arr): n = len(arr) # 遍历所有数组元素 for i in range(n): # Last i elements are already in place for j in range(0, n-i-1): if arr[j] > arr[j+1] : arr[j], arr[j+1] = arr[j+1], arr[j] arr = [64, 34, 25, 12, 22, 11, 90] bubbleSort(arr) print ("排序后的数组:") for i in range(len(arr)): print ("%d" %arr[i]) 排序后的数组: 11 12 22 25 34 64 90 参考https://www.runoob.com/python3/python3-examples.html 来源： https://www.cnblogs.com/xingnie/p/12245195.html