选择排序和冒泡排序哪个效率更高？百度说冒泡排序效率更高，但是我分别用这两种算法对一组数组进行排序，为什么结果是选择排序效率更高呢？代码如下：

1. package com.itheima;
   
2. /**
   
3. * @author Administrator
   
4. *
   
5. */
   
6. public class Test3 {
   
7.         private static final String LINE_SEPARATOR = System
   
8.                         .getProperty("line.separator");
   
9.         public static void main(String[] args) {
   
10. 
    
11.                 int[] arr = { 12, 34, 53, 2, -100, 60, 100, 89,12, 34, 53, 2, -100, 60, 100, 89 };
    
12.                 int[] arr2 = { 12, 34, 53, 2, -100, 60, 100, 89,12, 34, 53, 2, -100, 60, 100, 89 };
    
13.                 System.out.println("排序前数组：");
    
14.                 // 显示数组中元素
    
15.                 showArrElements(arr);
    
16.                 System.out.println(LINE_SEPARATOR + "使用选择排序算法排序后数组：");
    
17.                 // 排序算法循环的次数
    
18.                 int num = selectSort(arr);
    
19.                 showArrElements(arr);
    
20.                 System.out.println(LINE_SEPARATOR + "使用冒泡排序算法排序后的数组：");
    
21.                 int num2 = bubbleSort(arr2);
    
22.                 showArrElements(arr2);
    
23.                 System.out.println(LINE_SEPARATOR + "使用选择排序循环的次数为：" + num);
    
24.                 System.out.println("使用冒泡排序算法排序循环次数为：" + num2);
    
25.                 System.out.println("===============================");
    
26.         }
    
27.         /**
    
28.          * 冒泡排序
    
29.          *
    
30.          * @param arr
    
31.          * @return
    
32.          */
    
33.         private static int bubbleSort(int[] arr) {
    
34.                 int num = 0;
    
35.                 for (int i = 0; i < arr.length - 1; i++) {
    
36.                         for (int j = 0; j < arr.length - 1 - i; j++) {
    
37.                                 if (arr[j] > arr[j + 1]) {
    
38.                                         swap(arr, j, j + 1);
    
39.                                         num++;
    
40.                                 }
    
41.                         }
    
42.                 }
    
43.                 return num;
    
44.         }
    
45. 
    
46.         /**
    
47.          * 显示数组中的各个元素
    
48.          * @param arr
    
49.          */
    
50.         private static void showArrElements(int[] arr) {
    
51.                 // 遍历数组中元素并显示
    
52.                 for (int i : arr) {
    
53.                         System.out.print(i + " ");
    
54.                 }
    
55.         }
    
56. 
    
57.         /**
    
58.          * 选择排序算法
    
59.          *
    
60.          * @param arr
    
61.          */
    
62.         public static int selectSort(int[] arr) {
    
63.                 // 定义一个int变量，用于接收循环次数
    
64.                 int num = 0;
    
65.                 // 定义外循环，确定参与比较的元素
    
66.                 for (int i = 0; i < arr.length - 1; i++) {
    
67.                         // 判断前一个大于后一个，则进行位置置换
    
68.                         for (int j = i + 1; j < arr.length; j++) {
    
69.                                 if (arr[i] > arr[j]) {
    
70.                                         num++;
    
71.                                         swap(arr, i, j);
    
72.                                 }
    
73.                         }
    
74.                 }
    
75.                 return num;
    
76.         }
    
77. 
    
78.         /**
    
79.          * 交换数组中的元素
    
80.          *
    
81.          * @param arr
    
82.          * @param i
    
83.          * @param j
    
84.          */
    
85.         private static void swap(int[] arr, int i, int j) {
    
86.                 int temp = 0;
    
87.                 temp = arr[i];
    
88.                 arr[i] = arr[j];
    
89.                 arr[j] = temp;
    
90.         }
    
91. 
    
92. }
    

复制代码

请问这样来判断这种算法的效率合不合适呢？

软件设计师里面的有研究排序算法的效率是否稳定.如有兴趣,可以看一下

选择排序是每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
从算法角度看，选择排序是对冒泡排序的改进，他减少了必要的交换的次数，只是查找次数和冒泡排序一样N*(N-1)/2。所以毫不夸张的说任何情况下选择排序的效率不会低于冒泡排序。

效率高是指平均效率，具体要根据待排序的集合的顺序而定。就像领导年薪50W，民众年薪5W，国民收入27.5W和领导收入30W，民众收入25W，国民收入也是27.5W一样。

z1342802487 发表于 2014-4-27 19:13
选择排序是每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到 ...

我也感觉选择排序效率高点，但是为什么别人说冒泡效率高啊。、。