冒泡排序 | 易学教程

冒泡排序（java实现）

阅读更多关于冒泡排序（java实现）

冒泡排序介绍冒泡排序(Bubble Sort)，又被称为气泡排序或泡沫排序。它是一种较简单的排序算法。它会遍历若干次要排序的数列，每次遍历时，它都会从前往后依次的比较相邻两个数的大小；如果前者比后者大，则交换它们的位置。这样，一次遍历之后，最大的元素就在数列的末尾！采用相同的方法再次遍历时，第二大的元素就被排列在最大元素之前。重复此下面以数列{20,40,30,10,60,50}为例，演示它的冒泡排序过程(如下图)。我们先分析第1趟排序当i=5,j=0时，a[0]<a[1]。此时，不做任何处理！当i=5,j=1时，a[1]>a[2]。此时，交换a[1]和a[2]的值；交换之后，a[1]=30，a[2]=40。当i=5,j=2时，a[2]>a[3]。此时，交换a[2]和a[3]的值；交换之后，a[2]=10，a[3]=40。当i=5,j=3时，a[3]<a[4]。此时，不做任何处理！当i=5,j=4时，a[4]>a[5]。此时，交换a[4]和a[5]的值；交换之后，a[4]=50，a[3]=60。于是，第1趟排序完之后，数列{20,40,30,10,60,50}变成了{20,30,10,40,50,60}。此时，数列末尾的值最大。根据这种方法：第2趟排序完之后，数列中a[5...6]是有序的。第3趟排序完之后，数列中a[4...6]是有序的。

javascript冒泡排序

阅读更多关于 javascript冒泡排序

<!DOCTYPE html> <html lang = "en" > <head> <meta charset = "UTF-8" > <meta name = "viewport" content = "width=device-width, initial-scale=1.0" > <meta http-equiv = "X-UA-Compatible" content = "ie=edge" > <title> 数组 </title> </head> <body> <script> //冒泡排序 var arr = [ 99 , 44 , 66 , 55 ]; //0和1,2,3比较 arr[0]>arr[xxx] for ( var i = 0 ; i < 4 ; i ++){ //先确定某一个位置开始和后面的位置进行比较 for ( var j = i + 1 ; j < 4 ; j ++ ){ //后面位置起点应该是是确认下来的位置后一位 // debugger; if ( arr [ i ] < arr [ j ]){ //交换数值 var t = arr [ i ]; arr [ i ] = arr [ j ]; arr [ j ] = t ; } } } console . log ( arr ); //找出重复的值,求出相同的值出现的次数 var time =

（JAVA版）冒泡排序

阅读更多关于（JAVA版）冒泡排序

2019独角兽企业重金招聘Python工程师标准>>> 核心代码： public void bubbleSort (){ for ( int i = 0 ; i < length - 1 ; i ++ ){ for ( int j = 0 ; j < length - i - 1 ; j ++ ){ if ( a [ j ]> a [ j + 1 ]) swap ( j , j + 1 ); } } } public void swap ( int indexa , int indexb ){ int temp = a [ indexa ]; a [ indexa ] = a [ indexb ]; a [ indexb ] = temp ; } 主要代码 class Array { private int [] a ; private int length ; public Array ( int max ){ a = new int [ max ]; length = 0 ; } public void insert ( int value ){ a [ length ] = value ; length ++ ; } public void dispaly (){ for ( int i = 0 ; i < length ; i ++ ) System . out .

Java浅谈两种常用的排序

阅读更多关于 Java浅谈两种常用的排序

常用的排序方法有多种，这里只说说个人对选择排序和冒泡排序这两个最常用的排序方法的一些看法。首先，这里是按排序规则是按从小到大的顺序排序。然后，排序方法中接收的只有一个参数，即一个数组名。最后，排序后并未将排序后的数组元素依次输出，故而返回值是void ，至于输出操作，可另外自行定义。下面是具体的介绍。选择排序代码示例： for ( int i=0;i<arr. length -1;i++){ for ( int j=i+1;j<arr. length ;j++){ if (arr[i]>arr[j]){ swap (arr,i,j); 选择排序的思想是依次找到数组中的相对最小元素，并依次将其放于相应位置上。具体说来就是先找到最小元素，将其放于数组中第一个元素的位置，然后找到第二小元素，将其放于数组中第二个元素的位置。具体做法是让数组中第一个元素与后面所有元素进行比较，如果后面的元素比第一个元素小，则将它们位置互换，然后让当前第一个元素继续与后面的元素比较，也就是说，确保在已比较的元素中，当前第一个元素是最小的。这样的比较思想需要通过双层for 循环才能完成。具体如下：外层循环： for ( int i=0;i<arr. length -1;i++) 外层循环控制比较元素的起始位置，即当起始位置为0 时，要比较的是角标为0的元素和其后面的元素，依次类推

排序算法之冒泡排序

阅读更多关于排序算法之冒泡排序

冒泡排序，每一次从前往后两两比较找出一个最大的（或者最小的）。普通版： 1 def bubble_sort(alist): 2 """冒泡排序""" 3 n = len(alist) 4 # 这个循环负责控制冒泡排序进行的次数。对于长度为n的序列需要进行n-1次排序，但是range（）函数是从0开始产生数字的，故用n-1。 5 for i in range(n-1): 6 # 这个循环用于控制每一次具体的冒泡过程，即控制每一次冒泡排序冒泡两两比较的次数。 7 # 假如有三个数，第一次需要冒泡比较两次；第二次因为最后一个元素已经有序了，所以需要冒泡比较一次。因此这里的j每次都要减去i的值，即不冒“无用之泡泡” 8 for j in range(n-1-i): 9 if alist[j] > alist[j + 1]: 10 alist[j], alist[j + 1] = alist[j + 1], alist[j] 11 12 return alist 测试案例： 1 alist = [5,8,45,1,2,6,4,3] 2 bubble_sort(alist) 3 4 # 输出 5 [1, 2, 3, 4, 5, 6, 8, 45] 优化版：假设现在有一个数组[6,1,2,3,4,5]，当我们进行完第一次冒泡排序过程后变为[1,2,3,4,5,6]

js 冒泡排序

阅读更多关于 js 冒泡排序

　　前几天用到了冒泡排序的方法，现在整理了一下代码。我的需求是比较数组数据中的某一个字段中的值，而这个字段是有字母有数字，所以需要先匹配出来数字，然后截取出来数字，然后进行比较。我的数据是数组对象的格式，我需要对airport字段进行排序。　　首先拿到需求后，应该先将airport字段中的数字单独放在一个属性中，然后再根据这个属性进行排序。这个是我的思路。代码如下： matchData(data){//将数字的位置找出来，然后重新赋给新的属性 for (let i = 0; i < data.length; i++) { let index = data[i].airport.match(/[0-9]/).index data[i].position = Number(data[i].airport.substr(index,)) } }, bubbleSort(data){//冒泡排序 for (let i = 0; i < data.length; i++) { for (let j = 0; j < data.length -1 -i; j++) { if (data[j].position > data[j+1].position ) { let temp = data[j] data[j] = data[j+1] data[j+1] = temp } } } }

冒泡排序——Python实现

阅读更多关于冒泡排序——Python实现

冒泡排序Python实现 # -*- coding: utf-8 -*- # @Time : 2019/10/28 19:41 # @Author : yuzhou_1shu # @Email : yuzhou_1shu@163.com # @File : bubble_sort.py # @Software: PyCharm def bubble_sort(collection): # 求序列的长度 length = len(collection) # 从序列中第一个元素开始以此跟后一个比较 for i in range(length - 1): swapped = False for j in range(length - i - 1): if collection[j] > collection[j+1]: collection[j], collection[j+1] = collection[j+1], collection[j] swapped = True if not swapped: break # 如果已经排序好了，退出循环 return collection if __name__ == "__main__": import time user_input = input("请输入数字，并以英文逗号隔开: ").strip() unsorted = [int

面试题

阅读更多关于面试题

算法题: # 需求:两个列表合并，并排序 a = [1, 6, 3, 8, 5] b = [2, 3, 9, 4] c = a + b def mysorted(aList): """ 冒泡排序 :param c: :return: """ n=len(aList) for i in range(n): for j in range(n-i-1): if aList[j]>aList[j+1]: aList[j],aList[j+1]=aList[j+1],aList[j] return aList if __name__ == '__main__': result=mysorted(c) print(result) 来源： https://www.cnblogs.com/weihu/p/11753133.html

排序算法之冒泡排序插入排序希尔排序堆排序

阅读更多关于排序算法之冒泡排序插入排序希尔排序堆排序

简单排序排序算法的模板函数 void x_Sort ( ElementType A[], int N) 　　大多数情况下，为简单起见，讨论都是从小到大的整数排序 N 是正整数只讨论基于比较的排序（> = < 有定义）只讨论内部排序稳定性: 任意两个相等的数据，排序前后的相对位置不发生变化没有一种排序是任何情况下都表现最好的冒泡排序 void Bubble_Sort ( ElementType A[], int N ) { 　　int flag; 　　for ( int P = N - 1; P >= 0; P-- ){ 　　　　flag = 0; 　　　　for ( int i = 0; i < P; i++ ) { //一趟冒泡　　　　　　if ( A[i] > A[i+1] ) { 　　　　　　　　Swap ( A[i], A[i+1] ); 　　　　　　　　flag = 1;//标识发生了交换　　　　　　} 　　　　} 　　　　if ( flag == 0 ) break; //全称无交换　　} } 最好情况：顺序 T = O( N ）最坏情况：逆序 T = O( N^2 ) 冒泡排序算法是稳定的排序算法。插入排序 /**********插入排序算法***********************/ void Insertion

排序算法之冒泡排序的python实现

阅读更多关于排序算法之冒泡排序的python实现

冒泡排序算法的工作原理如下： 1. 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。 2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。 3. 除了最后一个，所有的元素重复以上的步骤。 4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。例子图步骤如下：冒泡排序代码实现: #!/usr/bin/env python # -*- coding:utf-8 -*- __author__ = "hsz" def bubble_sort(alist): # 外层循环控制比较几轮 n = len(alist) for j in range(n - 1): # 内存循环控制交换 # -j是不再换已经排好的 for i in range(n - 1 - j): # 若前一个比后一个大，则换 if alist[i] > alist[i + 1]: alist[i], alist[i + 1] = alist[i + 1], alist[i] # print(li) if __name__ == '__main__': li = [33, 11, 26, 78, 3, 9, 40] print("原来的列表：", li) bubble_sort(li) print("排序后的列表:", li) 来源：

订阅冒泡排序