码迷,mamicode.com
首页 > 编程语言 > 详细

算法1-冒泡排序

时间:2017-03-30 22:31:11      阅读:135      评论:0      收藏:0      [点我收藏+]

标签:介绍   比较   blog   java   ring   排序   效率   pack   length   

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

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

 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)。由于冒泡排序的时间复杂度非常高导致在实际开发中很少使用,只能作为算法入门程序学习下,下篇内容将介绍快速排序算法。

算法1-冒泡排序

标签:介绍   比较   blog   java   ring   排序   效率   pack   length   

原文地址:http://www.cnblogs.com/wangjian1990/p/6648911.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!