冒泡排序

1：冒泡排序 冒泡排序是相邻元素之间比较，如果是从前往后比较，则可以把最大的元素放入数组的最后一位，下一次循环把除最大的一位数外，剩下数的最大的再找出来，依次循环，把数组排序 using System; using System.Collections.Generic; using System.Diagnostics;//StopWatch类的命名空间 using System.Linq; using System.Text; using System.Threading.Tasks; namespace 直接插入排序 { class Program { static void Main(string[] args) { int[] array = new int[] { 42, 20, 99, 12, 44, 4, 66, 88, 24, 93 ,1,22};//需要排序的数组 Stopwatch watch = new Stopwatch();//创建StopWatch类的对象 watch.Start();//调用类中的start函数开始计时 Bubbing(array);//用冒泡排序算法对数组进行排序 watch.Stop();//调用StopWatch类中的stop函数，终止计时 Console.WriteLine(watch.Elapsed);/

1、冒泡排序 冒泡排序的基本思想就是：从无序序列头部开始，进行两两比较，根据大小交换位置，直到最后将最大（小）的数据元素交换到了无序队列的队尾，从而成为有序序列的一部分；下一次继续这个过程，直到所有数据元素都排好序。 # python [升序的排序] s = [3,4,5,6,7,12,11] n = len(s) i=0 j=0 for i in range(len(s)-1): for j in range(len(s)-1-j): ''' len(s)-1-j解释：这里减去j的意思是，最大的数已经在最下面没必要比较了。 ''' if s[j]>s[J+1]: temp = s[j+1] s[j+1] = s[j] s[j] = temp print (s) ########升序and 降序代码，改变判断符号即可 s = input().split() n = len(s) i =0 j =0 for i in range(n-1): for j in range(n-1): if s[n-j-2]<s[n-j-1]: temp = s[n-j-2] s[n-j-2]=s[n-j-1] s[n-j-1]=temp print(s) 当原始序列“正序”排列时，冒泡排序总的比较次数为n-1，移动次数为0，也就是说冒泡排序在最好情况下的时间复杂度为 O (n) ； 当原始序列“逆序

假如这个数组为int[ ] a={12,23,5,7,9,2} , 从小到大进行排序 **冒泡排序:**两两进行比较,大的往后放(如果排序从大到小,相反) 以下数组代表的是数组元素的下标,代表具体基表情况: 0-1 1-2 2-3 3-4 4-5 0-1 1-2 2-3 3-4 0-1 1-2 2-3 0-1 1-2 0-1 在这里插入代码片sjhj for(int i=0;i<a.length-1;i++){//外层循环代表需要比较的轮数,可以理解为行 for(int j=i+1;j<a.length-1-i;j++){//内层循环代表每轮比较的情况 if(a[j]>a[j+1]){ int temp=a[j]; a[j]=a[j+1]; a[j+1]=temp; } } }` 来源： https://blog.csdn.net/weixin_44158745/article/details/99093970

一、冒泡排序的介绍 冒泡排序(Bubble Sorting)的基本思想：通过对待排序序列从前向后（从下标较小的的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒。 因为在排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序的过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较（这里说的是优化，可以在冒泡排序写好后，在进行） 二、代码实现 package sort . bubble . demo ; import java . util . Arrays ; public class BubbleSort { public static void main ( String [ ] args ) { int arr [ ] = { 3 , 9 , - 1 , 10 , - 2 } ; //第一趟排序，就是将最大的数排在最后 int temp = 0 ; //临时变量 for ( int j = 0 ; j < arr . length - 1 ; j ++ ) { //如果前面的数比后面的大，则交换 if ( arr [ j ] > arr [ j + 1 ] ) { temp = arr [ j ] ; arr [ j ] = arr [ j + 1

  之前把常见的那几种算法看了好几次，看的时候也手写了一遍，可是等到过了 好几天又给忘了，所以决定记录下来分享一下，也方便自己以后查看😁 冒泡排序   冒泡排序是属于交换排序的一种，通过比较 相邻的两个数据 然后进行交 换，冒泡排序的时间复杂度为o(n^2)。 function BubbleSort(arr) { for(let i=0;i<arr.length;i++){ for(let j=0;j<arr.length-i-1;j++){ if(arr[j]>arr[j+1]){ [arr[j],arr[j+1]]=[arr[j+1],arr[j]]; //交换值 } } } return arr; } 选择排序   选择排序是通过 记录下标 的方式进行比较的，定义变量（index）等于当前 下标(i)，循环当前下标后面的元素，如果后面的元素比当前元素大（或者小），先不着急 交换元素，只 替换下标 （下标交换），一次循环过后最小元素下标的位置可以确定，最 终交换当前元素（arr[i]）值和最小（或最大）下标(arr[index])的值。选择排序的时间复杂度为o(n^2) // 选择 function chooseSort(arr){ for(let i = 0;i<arr.length;i++){ let index = i; //记录当前元素下标 for(let j =i+1

无论是迷宫游戏、扫雷游戏，还是常用的搜索引擎，甚至高端AI人机博弈等都需要算法来更好的实现。 算法是软件方面提升计算机效率的利器。 算法与数据结构分不开，用代码实现算法，至少会涉及到一种数据结构，数据结构通常有： 线性结构 树形结构 图 算法就要分别对应不同数据结构去排序。 当一个算法思想提出后，往往还需要更多时间去思考这个算法的优化。不断挖掘算法的潜力。 算法分类： 分治算法：归并排序、快速排序 贪心算法：最小生成树 动态规划：最短路径 递归搜索：树形结构 学习算法先从时间复杂度为O(n^2)学起，因为他们实现最简单，在并不复杂时，简单易用。高效率的算法往往实现也更复杂。 那就首先从算法从八大基本排序算的 冒泡排序法学起吧。 本文以升序排序为例。 冒泡排序定义及实现 冒泡排序，类似生活中于水中往上冒的气泡，越往上的气泡越大，故此得名。在冒泡排序中，每次比较前后两个数据，如果前一个比后一个大，则他们交换位置，这样从头到尾执行一次，则最大的数，就会被交换到最后一个位置，因为它比其他数都要打。进行第二轮排序，则次大的数会被交互到倒数第二位，以此类推。 首先来看一个基础的冒泡排序java代码实现： 从这里可以看到，因为有两次for循环每个循环最大会进行n次，所以时间复杂度为O(n^2). 优化一 优化1：在全部数据中，一旦前面有一个数比后面的大，就一定会发生交换，把大的数换到后面去。

原理 为什么叫冒泡排序？是因为小的浮出水面，大的数据都下降到了水底。 基本的思路是： 利用遍历的手段比较两个相邻的元素 ， 将值大的元素交换至右端。 模拟流程 如果有四个数 4 1 5 3， 第一趟，我们比较相邻的两个数 4和1，判断4比1大，交换4和1的位置，这时就变成了1 4 5 3，再比较 4和5，判断大小，不用交换位置，接着再比较5和3，判断大小，需要交换位置，这时候顺序就是1 4 3 5了。 第二趟，我们比较相邻的1和4，判断大小，不用交换位置；接着比较4和3，需要交换位置，顺序变为1 3 4 5。由于第一趟已经把最大的数字沉到了最后，所以 4和5不用进行比较了。 第三趟，我们继续比较1和4，不用交换位置，由于第二趟已经把4沉到最后，所以就不用进行3和4 的比较了。 代码实现 package 排序算法; /** * Author:haozhixin * Func: 冒泡排序算法 * Date: 20190809 */ public class BubbleSort { //基本的冒泡排序 public static void basicSort(){ int data[] = {4,1,5,3}; //这个表示要比较几趟，就是轮数。 //许多网上教学，视频教学都多比较了一轮，这个要注意下。 for(int i=0;i<data.length-1;i++){ /

冒泡排序及其优化 基础写法 优化 优化1 优化2 优化3 参考 基础写法 冒泡排序思想：泡泡一直向上冒，冒到不能冒的位置。即每次比较两个相邻元素，如果顺序不对就交换，这样一轮交换就能确定当前最大/小值。 假设数组 a r r a y [ 1... n ] array[1...n] a r r a y [ 1 . . . n ] ，按照从小到大排序，如果第1个元素大于第2个元素，则交换两个元素，一直到第n-1个元素和第n个元素比较，那么一轮结束，第n个元素一定是该数组的最大值，接下来第2轮对 a r r a y [ 1... n − 1 ] array[1...n-1] a r r a y [ 1 . . . n − 1 ] 进行相同操作，第n-1个元素一定是第2大元素。一共需要n-1轮比较。 以下代码全部按照从小到大排序。 void bubblesort ( vector < int > & numbers ) { int len = numbers . size ( ) ; if ( len <= 0 ) return ; int swapTmp ; for ( int i = 1 ; i < len ; i ++ ) //确定比较轮数 { for ( int j = 0 ; j < len - i ; j ++ ) //比较范围 { if ( numbers [ j ] >

最基础的排序——冒泡排序 假设有无序数组array[]长度为n，以由小到大排序为例。冒泡的原理是这样的： 1.比较相邻的前两个数据，如果前面的数据array[0]大于后面的数据array[1] (为了稳定性，等于就不交换)，将前面两个数据进行交换。在将计数器 i ++; 2.当遍历完n个数据一遍后，最大的数据就会沉底在数组最后array[n-1]。 3.然后n=n-1；再次进行遍历排序将第二大的数据沉到倒数第二位置上array[n-2]。再次重复，直到n=0；将所有数据排列完毕。 可以得出，冒泡在 n减到 0 为止，每遍近似遍历了n个数据。所以冒泡的时间复杂度是 -O(n^2)。 实现代码如下： public void sort (int[] array, int n) { int i = 0; int j = 0; int temp = 0; for(i = 0; i < n; i++){ for(j = 1; j < n - i; j++){ if(array[j - 1] > array[j]){ temp = array[j-1]; array[j - 1] = array[j]; array[j] = temp; } } } } 　　时间复杂度逻辑上是-O(n^2)，所以冒泡还是效率比较低下的，数据较大时，建议不要采用冒泡。 来源： https://www.cnblogs

冒泡排序原理：就像石头沉入水底一样，选取数组中最大的元素放在数组最后的位置 每次选取数组中的第一个元素与其后面的元素依次进行比较，若前一个元素比后一个元素大，则进行位置交换 例如：数组 int[] a = {9，5，4，2，7，3} 第一趟： 5 ， 9 ，4，2，7，3 （9比5大，交换位置） 5， 4 ， 9 ，2，7，3 （9比4大，交换位置） 5，4， 2 ， 9 ，7，3 （9比2大，交换位置） 5，4，2， 7 ， 9 ， 3 （9比7大，交换位置） 5，4，2，7， 3 ， 9 （9比3大，交换位置） 这样数组中最大的就到了最后一个位置：5，4，2，7，3，9 第二趟： 4，5 ，2，7，3，9 （5比4大，交换位置） 4， 2，5， 7，3，9 （5比2大，交换位置） 4，2， 5，7 ，3，9 （7比5大，不交换位置） 4，2，5， 3，7 ，9 （7比3大，交换位置） 因为9已经是最大的数了，所以7不会和9比较 这样数组数组中第二大的元素也找到了位置：4，2，5，3，7，9 第三趟： 2，4 ，5，3，7，9 （4比2大，交换位置） 2， 4，5 ，3，7，9 （4比5小，不交换位置） 2，4， 3，5 ，7，9 （5比3大，交换位置） 所以现在的顺序为：2，4，3，5，7，9 第四趟： 2，4 ，3，5，7，9 （2比4小，不交换位置） 2， 3，4 ，5，7