冒泡排序

#!/usr/bin/python def bubble_sort(li): for i in range(len(li)-1): #躺数循环 最后一个数不用比较 已经是最大或者最小的数 所以躺数减少1 exchange = False #增加标识 以减少循环次数 for j in range(len(li)-i-1): # len(li)-i 表示列表中剩下的无序的列表。每比较一次 则剩下的列表长度减少1。无序列表躺数 if li[i] > li[j+1]: #第一个数和第二个进行比较 如果第一个数大于第二个数就进行交换（升序） #if li[i] < li[j+1]: 第一个数小于第二个数就进行交换（降序） li[i],li[j+1] = li[j+1],li[i] exchange = True # 如果发生交换，那么证明列表中还是有需要进行比较 即无序状态 if not exchange: #如果没有发生改变，那么已经排序完毕，结束循环（对于不是非常混乱的列表，可以减少循环次数，节省时间，结束算法即可） return 来源： https://www.cnblogs.com/ikai/p/11589733.html

/** * 冒泡排序 * @author Administrator * */ public class TestArray { public static void main(String[] args) { int[] arr = {5,2,6,9,4,3,1,7,8}; for (int i = 0; i < arr.length -1; i++) { //外层循环是程序需要执行多少趟 for (int j = 0; j < arr.length - 1 - i; j++) { //内层循环是每趟需要比较多少次 if (arr[j] > arr[j + 1]) { int temp = arr[j]; //定义临时变量储存数据 arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } print(arr); } public static void print(int[] arr) { for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } } 来源： https://www.cnblogs.com/sacai/p/11588547.html

冒泡排序–python def Bubblesort ( list1 ) : length = len ( list1 ) for i in length : for j in range ( 0 , length - i - 1 ) : if list1 [ j ] > list1 [ j + 1 ] : list1 [ j ] , list1 [ j + 1 ] = list1 [ j + 1 ] , list1 [ j ] 来源： https://blog.csdn.net/yangyu11111/article/details/101350113

思路：每遍历一次找出数组中最大值放在最末尾，接着下一次遍历就数组长度-1，继续找出这次数组中的最大值。 function bubble(arr){ for(var i=0;i<arr.length-1;i++){ /*最后一次遍历数组只剩一个元素，*无需再遍历 所以arr.length-1 */ for(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; } } } return arr; } var arr=[10,50,5,25,19,11]; console.log(bubble(arr)); 来源： https://blog.csdn.net/huanxianxianshi/article/details/101347609

java冒泡排序 主要知识点 顾名思义，就是从下标小的数开始，向右边临近元素比较，遇到比自己小的数就交换，下标加一，继续与右边临近的元素交换。就像一层一层向上冒出的气泡一样。 演示范例 给定一个数组1,-34,22,56,23,54 开始排序 第一次：-34，1，22，56，23，54 第二次：-34，1，22，56，23，54 第三次：-34,1,22,56,23,54 第四次：-34,1,22,56,23,54 +> -34,1,22,23,56,54 第五次：-34,1,22,23,56,54 =>-34,1,22,23,54,56 一轮排序完成后，数组的最后一个数为最大的数 以此类推，第二轮排序之后，倒数第二个数也是最大的数。 所以不需比较次数。 得出结论 每一轮可以少进行一次比较。 优化 冒泡排序本身没有记忆性，所以他总是进行size-1次排序，有时，在之前的排序中就已经将数组排序完成，这造成了浪费，占用时间。所以在进行交换时，进行计数， 如果计数次数为0，则跳出排序循环，返回已经排序好的数组。 public class PopSort { static int sortCount = 0; public static void main(String[] args) { int[] data = {1,-34,22,56,23,54}; int[] sort = new

冒泡排序算法 代码 理解分析 在排序算法中，冒泡排序算法是最容易理解的，当然从效率上来讲并不是很高，所以在排序算法中，冒泡算法只能作为基础，在理解冒泡算法后需要进一步去学习其他的算法。 引用自个人网站： http://beself.top/2019/11/25/alg-bubble-sort/ 代码 void BubbleSort ( vector < int > & arr ) { uint32_t size = arr . size ( ) ; for ( uint32_t i = 0 ; i < size ; ++ i ) { for ( uint32_t j = 0 ; j < size - i - 1 ; ++ j ) { if ( arr [ j ] > arr [ j + 1 ] ) { int v = arr [ j ] ; arr [ j ] = arr [ j + 1 ] ; arr [ j + 1 ] = v ; } } } } 理解分析 在程序中使用里那个循环来进行排序，程序以降序作为示例。内 循环中每次前一个数与后一个数据进行比较 ，如果第一个数比第二个数大，那么两个数进行交换，到整个内循环后将会把容器中最大的一个数找到并放在最后一个位置，外循环控制次数，每次都会找到最大的一个数。 来源： CSDN 作者： ALONE_WORK 链接： https:/

1、概念：什么是冒泡排序算法？冒泡排序，该算法的核心思想是将无序表中的所有记录，通过两两比较关键字，得出升序序列或者降序序列。2、代码演示：package com.zhangwl.pg0922.pg01;import java.util.Arrays;/** * @ClassName BubblingSort * @Description 冒泡排序 * @Author zhangwl * @Date 2019/9/22 15:59 * @Version 1.0 **/public class BubblingSort { private static final int[] iArr = {52, 67, 1, 3, 68, 40, 18, -1}; public static void main(String[] args) { int[] iArr = BubblingSort.bubblingSort(BubblingSort.iArr); for (int e : iArr) { System.out.print(e + " "); } } /** * 对数组进行冒泡排序 * * @param iArr * @return */ public static int[] bubblingSort(int[] iArr) { int tempVal = 0; for (int

python 十大经典排序算法 排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括： 关于时间复杂度： 平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。 线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序。 O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。 希尔排序。 线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。 关于稳定性： 稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。 不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。 名词解释： n：数据规模 k：“桶”的个数 In-place：占用常数内存，不占用额外内存 Out-place：占用额外内存 稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同 冒泡排序 冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成

在面试过程中,经常会涉及到一些算法问题,下面说介绍一下冒泡排序算法及优化. 冒泡排序分为从大到小和从小到大两种排序方式,唯一区别在于两个数交换的条件不同, 从大到小排序是前面的数比后面的小时交换,而从小到大排序是前面的数比后面的数大的时候交换. 假设有N个数据放在数组nums中,现将数组nums中的N个数据从小到大进行排序 假设使用冒泡排序算法对5个整数 {8，3，-2，7，6} 进行从小到大的排序 冒泡排序的基本思想: 在a[0] 到a[n-1]的范围内,依次比较两个相邻元素的值,若a[j]>a[j+1] 则交换a[j] 和a[j+1] 否则不作交换, 直至完成最后一次循环比较. 如图可知：数组长度为n, 外层共循环n-1次, 外层循环增加一次 对应的内层循环就减少一次 外层循环控制比较的轮数, 内层循环控制的比较的次数 外层循环： for(int i=0; i<nums.length-1; i++) 内层循环： for(int j=0; j<nums.length-1-i; j++) 交换两个相邻元素的值： int temp = nums[j]; nums[j] = nums[j+1]; nums[j+1] = temp; 代码 实现 ： 运行效果： 冒泡排序算法优化： 回顾一下刚刚描述的排序细节,仍以8，3，-2，7，6这个数组为例 经过第二轮排序后,整个数组已经是有序的了

算法思想 # 　　冒泡排序属于一种典型的交换排序。 　　交换排序顾名思义就是通过元素的两两比较，判断是否符合要求，如过不符合就交换位置来达到排序的目的。冒泡排序名字的由来就是因为在交换过程中，类似水冒泡，小（大）的元素经过不断的交换由水底慢慢的浮到水的顶端。 　　冒泡排序的思想就是利用的比较交换，利用循环将第 i 小或者大的元素归位，归位操作利用的是对 n 个元素中相邻的两个进行比较，如果顺序正确就不交换，如果顺序错误就进行位置的交换。通过重复的循环访问数组，直到没有可以交换的元素，那么整个排序就已经完成了。 示例 # 　　我们通过一个示例来理解一下基本的冒泡排序，假设当前我们有一个数组 a，内部元素为 3，4，1，5，2，即初始状态，如下图所示。我们的目的就是通过 n 趟比较来实现有底向上从大到小的的顺序。 第一遍排序 # 　　我们首先进行第一遍排序，如下图所示，红色代表当前比较的元素，绿色代表已经归位的元素。 　　（1）比较第一个和第二个元素，4>3，交换。 　　（2）比较第二个和第三个元素，1<3，不交换。 　　（3）比较第三个和第四个元素，5>1，交换。 　　（4）比较第四个和第五个元素，2>1，交换。 　　最后，我们可以看到 1 已经位于最顶部。第一遍需要尽心四次比较才能把五个数比较完。 第二遍排序 # 　　第二遍排序的初始状态是第一遍排序的最终状态，即4，3，5，2，1