冒泡排序

冒泡排序 原理 通过比较数列相邻的元素大小，交换位置，从而将最大的或者最小的数一层层浮到顶端，像汽水中的气泡一样，故称冒泡排序。 总结： 1.对于一个长度为n的数列需要经过n-1轮的排序。 2.每一轮排序需要经过n-i次交换位置。i为第几轮。 时间复杂度 从下面的代码可以看出，长度为5的列表共经过10次排序。 4+3+2+1=10 所以推导长度为n的列表共执行n-1+n-2...+2+1 首尾相加,一共有n-1项，每2项的和为n =(1+n-1)+(2+n-2)+... =n×(n-1)÷2 时间复杂度一般忽略低阶，常量，系数三个部分，所以最终最坏时间复杂度为O(n²) 代码实现 a=[9,5,4,3,2] def bubble(arr): length=len(arr) print("原始数列是%s"%arr) for i in range(length-1): print("第%s轮"%str(i+1)) for j in range(length-1-i): if arr[j]>arr[j+1]: arr[j],arr[j+1]=arr[j+1],arr[j] print("第%s次后的结果是%s"%(str(j+1),arr)) return arr print(bubble(a)) 来源： https://www.cnblogs.com/King-Tong/p

快速排序法 //1.找一个基准点 //2.建立两个数组，分别存储左边和右边的数组 //3.利用递归进行下次比较 function quictSort (arr) { if (arr.length <= 1) { return arr; } var left = []; var right = []; var num = Math.floor(arr.length / 2); //找到数组中间那个数，若是偶数，则因为向下取整所以找到前一位 var numValue = arr.splice(num,1); for (var i = 0; i <arr.length; i++) { if (arr[i] < numValue) { left.push(arr[i]); }else{ right.push(arr[i]); } }; return quictSort(left).concat([numValue],quictSort(right)); } document.write(quictSort([5,8,99,74,62,24])); 冒泡排序法 1比较相邻的元素。如果第一个比第二个大，就交换它们两个； 2对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数； 3针对所有的元素重复以上的步骤，除了最后一个； 4重复步骤1~3，直到排序完成

package com . jmdf ; import java . util . Arrays ; /** * 算法--冒泡排序n个数 * 复杂度-- ((（n-1）+1)*(n-1))/2 * 最差 (n²-n)/2 * 最优 1 * O(n²) */ public class Algorithm { public static void main ( String [ ] args ) throws Exception { int [ ] a = source ( ) ; System . out . println ( ) ; try { Thread . sleep ( 1000 ) ; } catch ( InterruptedException e ) { e . printStackTrace ( ) ; } int [ ] b = sort ( a ) ; result ( b ) ; } public static int [ ] source ( ) { int [ ] a = { 5 , 4 , 3 , 2 , 1 } ; System . err . print ( "冒泡排序前:" ) ; try { Thread . sleep ( 1000 ) ; } catch ( InterruptedException e ) { e .

算法学习笔记—排序 这是最近在学习过程中整理的一部分笔记，没有图片演示，如需更生动的展示可以看这位大牛的整理博客。 排序算法的动画演示 文章目录 算法学习笔记---排序 常见的一些数组排序方法 冒泡排序 选择排序 插入排序 归并排序 快速排序 随机快速排序 堆排序 桶排序 排序方法的稳定性 比较器 递归的实质 对数器 和排序相关的经典问题 小和问题 逆序对问题 荷兰国旗问题 最大间隔问题 常见的一些数组排序方法 冒泡排序 冒泡排序的原理： 相邻位进行比较，如果满足前面的数大于后面的数，就交换前后两个数。排一个来回之后，数组中最大的数已经被移动到了最后面。 时间复杂度的分析：N+(N-1)+(N-2)+… 等差数列，O(N2) 冒泡排序的代码实现： public void bubbleSort ( int [ ] arr ) { if ( arr == null || arr . length < 2 ) { //数组为空或者数组中只有一个元素，不需要进行排序 return ; } for ( int end = arr . length - 1 ; end > 0 ; end -- ) { //使用end来标记当前比较移动操作的最后一位是多少。 //第一波比较从索引0到索引arr.length //第二波比较从索引0到索引arr.length-1 for ( int i = 0 ;

冒泡排序是非常容易理解和实现，，以从小到大排序举例： 设数组长度为N。 1．比较相邻的前后二个数据，如果前面数据大于后面的数据，就将二个数据交换。 2．这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。 3．N=N-1，如果N不为0就重复前面二步，否则排序完成。 按照定义很容易写出代码： //冒泡排序1 void BubbleSort1(int a[], int n) { int i, j; for (i = 0; i < n; i++) for (j = 1; j < n - i; j++) if (a[j - 1] > a[j]) Swap(a[j - 1], a[j]); } 下面对其进行优化，设置一个标志，如果这一趟发生了交换，则为true，否则为false。明显如果有一趟没有发生交换，说明排序已经完成。 //冒泡排序2 void BubbleSort2(int a[], int n) { int j, k; bool flag; k = n; flag = true; while (flag) { flag = false; for (j = 1; j < k; j++) if (a[j - 1] > a[j]) { Swap(a[j - 1], a[j]); flag = true; } k--; } } 再做进一步的优化

**var arr = [5,8,4,9]; for(var i =0;i<arr.length-1;i++){ for(var j = 0;j<arr.length-i-1;j++){ if(arr[j]>arr[j+1]){ var temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } //冒泡排序相当于做升序** 来源： CSDN 作者： qq_45457134 链接： https://blog.csdn.net/qq_45457134/article/details/104442006

冒泡排序象一个气泡从河底往上冒的过程一样，每次排序都把最大的数据放到最后，具体的第一趟冒泡排序的过程为：比较第一个数据元素x[0]与第二个数据元素x[1]的大小，若x[0]<x[1],则交换两者的值，否则什么都不做；接着跟x[2],x[3]…比较，直到x[n-1]与下x[n-2]的比较。接着第二、三…趟冒泡排序，过程与上一趟相同，只不过只需比较到比上一趟前一个位置即可。 快速排序是冒泡排序的一种改进。每趟冒泡排序只是从小于该趟的最大值的一端进行比较，而快速排序每次任取一个枢纽元（可为最大值），然后从大于和小于该枢纽元两个方向进行比较。 具体的实现代码如下所示 （代码的注释过程有快速排序的具体做法） #include<stdio.h> //冒泡排序的函数定义 void Bubble(int x[], int n) { int i, j; for(i=1;i<=n-1;i++) //排序的次数 for (j = 1; j <= n - i; j++) {//进行一次冒泡排序 if (x[j] > x[j + 1]) { x[0] = x[j + 1]; x[j + 1] = x[j]; x[j] = x[0]; } else break; } } //以下为快速排序的相关函数的定义 int Partition(int x[], int low, int high) {/

关注“python趣味爱好者”公众号，回复“排序算法”获取源代码 目前,常见的排序算法有: 冒泡排序 插入排序 选择排序 堆排序 计数排序 快速排序 本篇文章将围绕这七大算法进行介绍,我们先来学习一下整体的代码结构: class SORT ( object ) : def __init__ ( self ) : self . arr = [ 20 , 64 , 34 , 25 , 12 , 22 , 11 , 90 ] self . n = len ( self . arr ) self . num = 0 print ( self . arr ) def out_put ( self ) : print ( 50 * '-' ) print ( "最终排序结果" , self . arr ) def bubbleSort ( self ) : #冒泡排序 pass def shellSort ( self ) : #希尔排序 pass def insertionSort ( self ) : #插入排序 pass def Selectionsort ( self ) : #选择排序 pass def heapSort ( self ) : #堆排序 pass def countSort ( self ) : #计数排序 pass def quickSort ( self ) :

冒泡排序 来源： https://www.cnblogs.com/ZengBlogs/p/12332307.html

文章目录 冒泡排序 代码 时间复杂度分析 改进 选择排序 冒泡排序 冒泡排序的算法思路在于对无序表进行多趟比较交换 每趟包括了多次两两相邻比较，并将逆序的数据项交换位置，最终将本趟的最大项就位 经过n-1趟比较交换，实现整表排序 第n-1趟完成后，最小项一定在列表首位，无需再处理。 第s趟比较交换时，需要排序的数据减少为n-s+1，共有n-s对相邻数据进行比较。 代码 def bubbleSort ( alist ) : for passnum in range ( len ( alist ) - 1 , 0 , - 1 ) : #n-1趟 for i in range ( passnum ) : if alist [ i ] > alist [ i + 1 ] : alist [ i ] , alist [ i + 1 ] = alist [ i + 1 ] , alist [ i ] alist = [ 54 , 26 , 93 , 17 , 77 , 31 , 44 , 55 , 20 ] bubbleSort ( alist ) print ( alist ) [17, 20, 26, 31, 44, 54, 55, 77, 93] 时间复杂度分析 复杂度分析：无序表初始数据项的排列状况对冒泡排序没有影响 算法过程总需要n-1趟，随着趟数的增加，比对次数逐步从n-1减少到1