算法1-冒泡排序

Posted 2020-09-07 程序员的未来是写程序

冒泡排序的定义：每次比较两个相邻的元素，如果它们的顺序错误就把它们交换过来。

以下是我学习算法之前一直用的排序算法：

 1 package test.com;
 2 
 3 import Java.util.Arrays;
 4 import java.util.Random;
 5 
 6 public class BubbleSort {
 7 
 8 
 9     public static void main(String[] args) {
10 
11         int len = 10;//生成10位随机数
12         int[] score = getIntArrays(len);
13         System.out.println(Arrays.toString(score));//打印原始数组
14         for(int i=0;i<len;i++){
15             for(int j=0;j<len;j++){
16                 if(score[i]<score[j]){
17                     score[i] = score[i] ^ score[j];
18                     score[j] = score[i] ^ score[j];
19                     score[i] = score[i] ^ score[j];
20                 }
21             }
22         }
23         System.out.println(Arrays.toString(score));
24     }
25 
26     /**
27      * 产生length位随机数数组
28      * @param length
29      * @return
30      */
31     private static int[] getIntArrays(int length){
32         int[] intArrays = new int[length];
33         Random random = new Random();
34         for(int i=0;i<length;i++){
35             intArrays[i] = (int) (100 * random.nextFloat());
36         }
37         return intArrays;
38 
39     }
40 
41 }

以上实现的算法并不符合冒泡排序的定义，但是它简单易懂，从左到右每位数都循环比较一遍，如果顺序不对就交换顺序，由此可以看出上面的代码比冒泡排序的执行效率要低，以下代码为按照冒泡排序算法定义实现的代码：

 1 package test.com;
 2 
 3 import java.util.Arrays;
 4 import java.util.Random;
 5 
 6 public class BubbleSort {
 7 
 8 
 9     public static void main(String[] args) {
10         int len = 10;//生成10位随机数
11         int[] score = getIntArrays(len);
12         System.out.println(Arrays.toString(score));//打印原始数组
13         //冒泡排序实现
14         for(int i=0;i<len-1;i++){
15             for(int j=0;j<len-i-1;j++){
16                 if(score[j]<score[j+1]){
17                     score[j+1] = score[j+1] ^ score[j];
18                     score[j] = score[j+1] ^ score[j];
19                     score[j+1] = score[j+1] ^ score[j];
20                 }
21             }
22         }
23         //排序后结果
24         System.out.println(Arrays.toString(score));
25 
26 
27     }
28 
29     /**
30      * 产生length位随机数数组
31      * @param length
32      * @return
33      */
34     private static int[] getIntArrays(int length){
35         int[] intArrays = new int[length];
36         Random random = new Random();
37         for(int i=0;i<length;i++){
38             intArrays[i] = (int) (100 * random.nextFloat());
39         }
40         return intArrays;
41 
42     }
43 
44 }

最后总结一下，冒泡排序的时间复杂度为比较的次数(n^2-n)/2=n(n-1)/2,然而我们在说时间复杂度的时候可以忽略较小的常数，最终冒泡排序的时间复杂度为O(n^2)。由于冒泡排序的时间复杂度非常高导致在实际开发中很少使用，只能作为算法入门程序学习下，下篇内容将介绍快速排序算法。