冒泡排序

本文是关于本人对冒泡排序的一些理解，如有错误，还望大神指正。 注：本文的排序都是指升序序列。 先来了解一下，冒泡排序是怎么排序的？原理是怎样的？ 如下图，将每一个元素都与其后面的元素进行比较，每一轮过后，都将最大的元素放到最右侧，也就是像“冒泡”一样。 让我们看看每一轮“冒泡”后的结果，见下图。 冒泡排序算法–Java版 static void sort ( int [ ] arr ) { int temp ; //总共比较 n - 1 轮 for ( int i = 0 ; i < arr . length - 1 ; i ++ ) { //每轮比较 （n - 已确定好元素位置的个数 - 1） 次 for ( int j = 0 ; j < arr . length - 1 - i ; j ++ ) { if ( arr [ j ] > arr [ j + 1 ] ) { temp = arr [ j ] ; arr [ j ] = arr [ j + 1 ] ; arr [ j + 1 ] = temp ; } } } } 这样就可以将所有元素按照大小排好序，非常好。但是仔细想想，这样有什么弊端呢？如果是几个月前刚接触算法的我，回答这个问题，我肯定会说：这样都排好序了，不是挺好的么？ 其实冒泡排序的效率是不高的，举个栗子就能明白了。体育课上老师让按大小个排成一队

//冒泡排序 package test; public class Maopaosort { public static void method(){ int[] arr=new int[10]; for(int i=0;i<arr.length;i++){ arr[i]=(int) (Math.random()*100+1); } System.out.println(); for(int num:arr){ System.out.print(num+" "); } System.out.println(); for(int i=0;i<arr.length-1;i++){ for(int j=0;j<arr.length-1-i;j++){ int tem; if(arr[j]<arr[j+1]){ tem=arr[j]; arr[j]=arr[j+1]; arr[j+1]=tem; } } System.out.println("这是第"+(i+1)+"次排序结果："); for(int num:arr){ System.out.print(num+" "); } System.out.println(); } System.out.println("最终排序结果为："); for(int num:arr){ System.out.print(num+" "); } }

1.原理 在无序区间内, 通过相邻数的比较, 将最大的数冒泡到无序区间的最后, 持续这个过程, 直到数组整体有序 2.代码实现 import java.util.*; public class bubbleSort{ public static void bubbleSort(int[] array){ for(int i = 0; i < array.length - 1; i++){ //减治算法 for(int j = 0; j < array.length - i - 1; j++){ // -i表示每次遍历都会少一个数 //相等不交换, 保证稳定性 if(array[j] > array[j+1]){ swap(array, j, j+1); } } } } public static void swap(int[] array, int a, int b){ int temp = array[a]; array[a] = array[b]; array[b] = temp; } public static void main(String[] args){ //打印测试 int[] array = {3,4,9,2,6,5,6,12}; bubbleSort(array); for(int i = 0; i <= array.length - 1; i++){

1 #include<iostream> 2 #include<iomanip> 3 #include<time.h> 4 using namespace std; 5 const int N=10; 6 7 void BubbleSort(int arr[], int n) 8 { 9 int i, j, t; 10 for(i=0;i<n-1;i++) 11 { 12 for(j=0;j<n-i-1;j++) 13 { 14 if(arr[j]>arr[j+1]) 15 { 16 t=arr[j+1]; 17 arr[j+1]=arr[j]; 18 arr[j]=t; 19 } 20 } 21 } 22 } 23 24 int main() 25 { 26 int a[N], i; 27 srand(time(NULL)); 28 for(i=0;i<N;i++) 29 a[i]=rand()%100; 30 for(i=0;i<N;i++) 31 cout<<setw(4)<<a[i]; 32 cout<<endl; 33 34 BubbleSort(a,N); 35 for(i=0;i<N;i++) 36 cout<<setw(4)<<a[i]; 37 cout<<endl; 38 } #include<stdio.h> #include<stdlib.h>

冒泡排序算法:轻者上浮，重者下沉。（或者正好相反） 基本思想： 1.比较相邻的元素。 2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。 3.针对所有的元素重复以上的步骤，除了最后一个。 4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 本质上是： 第一趟，选出最大（或最小）元素，第二趟，选出次大（或次小的）的元素….. 示例： 定义数组：{ 4, 2, 62, 9, 22, 1,14,10 } 第1趟排序后：[2, 4, 9, 22, 1, 14, 10, 62] //选取最大元素62，放在了最后 第2趟排序后：[2, 4, 9, 1, 14, 10, 22, 62] //选出了次大元素22 ，放在了倒数第二位…. 第3趟排序后：[2, 4, 1, 9, 10, 14, 22, 62] 第4趟排序后：[2, 1, 4, 9, 10, 14, 22, 62] 第5趟排序后：[1, 2, 4, 9, 10, 14, 22, 62] 第6趟排序后：[1, 2, 4, 9, 10, 14, 22, 62] 第7趟排序后：[1, 2, 4, 9, 10, 14, 22, 62] 代码： int i,j,t; int [] a={4,2,6,9,22,1,100}; for( i=0;i<n-1;i++){ for( j=0;j<n-i-1;j++){

int score[] ={60,54,89,32,45} for(int i=0;i<score.Length-1;i++) //控制循环趟数 { 　　for(int j=0;j<score.Length-1-i;j++) //控制循环次数 　　{ 　　　　if(score[j]<score[j+1]) //当前数小于后面的数 成立就交换位置 冒泡排序 　　　　{ 　　　　　　int temp=score[j]; 　　　　　　score[j]=score[j+1]; 　　　　　　score[j+1]=temp; 　　　　} 　　} } 来源： https://www.cnblogs.com/jimsu/p/11183896.html

第一种：选择排序 第二种：冒泡排序、改进冒泡排序 第三种：插入排序 第四种：快速排序 第五种：归并排序 #include<iostream> #include<cstring> using namespace std; const int MAXN=1000; int a[MAXN]; int n; //选择排序 void xuanze(){ int k; for(int i=0;i<n;i++){ k=i; for(int j=i+1;j<n;j++) if(a[j]<a[k]) k=j; //注意是a[j]<a[[k] if(k!=i) { swap(a[i],a[k]); } } cout<<"选择排序如下： "; for(int i=0;i<n;i++) cout<<a[i]<<" "; cout<<endl; } //冒泡排序 void maopao(){ for(int i=n-1;i>=1;i--){ for(int j=0;j<i;j++){ if(a[j]>a[j+1]) swap(a[j],a[j+1]); } } cout<<"冒泡排序如下： "; for(int i=0;i<n;i++) cout<<a[i]<<" "; cout<<endl; } //改进冒泡排序 void impmaopao(){ bool ok; for(int i=n-1;i>=1

冒泡排序 算法思想 冒泡排序是最简单的排序算法之一，在给定的序列中，依次的比较两个数字，如果顺序错误就交换两个数字的位置。然后重复步骤，直到整个给定的序列符合要求位置。 算法步骤: 比较相邻的两个数字，如果第一个比第二个数字大，那么交换两个数字的位置；否则，继续下一个位置的比较 对每一对相邻的元素做同样的工作，遍历完整个序列以后，最后的数字一定是最大的数字 针对所有的数字，重复以上步骤，除了最后一个（这里的最后一个不是特指所有给出的序列的最后一个，而是相对于上次比较的最后一个，是 相对的位置 ） 重复1~3，直到整个给定的序列排序完成 下面结合动画，可以更加清楚的理解上述的算法步骤： 从上面的算法步骤及动画中，可以分析冒泡排序的 时间复杂度 是 O ( n 2 ) O(n^2) O ( n 2 ) ，并且是一种 稳定 的排序算法（如何决定算法是否稳定，如果有两个相同的数字，比如 arr=[3,4,1,3]，如果排序完成以后，下标为0的3，仍然在下标为3的3的前面，就表示是稳定的），整个排序过程中只需要有限个临时遍历用于数据的交换，所以 空间复杂度 为 O ( 1 ) O(1) O ( 1 ) 。 代码实现 # include <iostream> # include <vector> using namespace std ; void bubbleSrot ( vector <

首先我们先了解一下什么是冒泡排序 冒泡排序：就是给定一个数组，然后依次从左到右相邻的两个数两两比较，如果是升序排列，如果前面一个数大于后面一个数就交换位置，直到遍历到最后一个，然后进行第二轮的比较，第二轮的比较仍然从第一数开始，进行两两比较，然后进行第三轮，依次类推 下面我们举例来具体阐述一下： 给定一个数组，进行排序：2，6，1，3，8，5从小到大的顺序排列 第一轮：遍历整个数组，相邻两个两两比较，如果前面大于后面，就交换 2，6 ，1，3，8，5—>2， 1，6 ，3，8，5—》2，1， 3，6 ，8，5—》2，1，3， 6，8 ，5—-》2，1，3，6， 5，8 那么第一轮比较就结束了最后的结果：2，1，3，6，5，8 那么我们用代码实现这个过程 在这个之前我们先了解一下Java中数组类型的变量的声明和赋值以及遍历打印 //先定义一个数组，由于数组是对象，所以定义的时候应该new一下 //在定义数组的同时进行快速赋值 int[] num = new int[]{2,6,1,3,8,5}; System.out.println(num);//这里打印只是一个数组的引用的地址 //遍历的方法打印数组 for(int i=0;i<num.length;i++){ System.out.print(num[i]+","); } System.out.println("\n"); /

冒泡排序 冒牌排序算法时间复杂度最坏的情况是，最好的，说明冒泡排序是可以优化的，就看你有没有去发现。 冒泡排序算法的过程是两个元素比较的大小，是典型的交换排序算法。快速排序算法和鸡尾酒排序算法也属于交换排序。我这篇介绍完之后下一篇章会介绍快速排序和鸡尾酒排序。所以要自己学会关注哦，给这个公众号标上星标，不会迷失下一篇好文。 排序方法 比较相邻的元素，判断是否符合要求，如果不符合就交换位置来达到排序的目的。 对每一对相邻元素做相同的工作，从开始第一对到结尾的最后一对，一次遍历之后，最后一个元素是最大（小）的数。 第二次遍历重复以上操作，因为最后一个元素已经确定位置，减少一次计算。以此类推。 示例 通过一个示例来理解基本的冒泡排序算法，假设当前我们有一个数组a，里面元素是：5，6，1，7，2，4，3 初始状态 视频动画 算法动画视频 地址 Code Result 初始状态[5, 6, 1, 7, 2, 4, 3]发生交换[5, 1, 6, 7, 2, 4, 3]发生交换[5, 1, 6, 2, 7, 4, 3]发生交换[5, 1, 6, 2, 4, 7, 3]发生交换[5, 1, 6, 2, 4, 3, 7]1次遍历：[5, 1, 6, 2, 4, 3, 7]发生交换[1, 5, 6, 2, 4, 3, 7]发生交换[1, 5, 2, 6, 4, 3, 7]发生交换[1, 5, 2,