冒泡，选择，插入排序的效率比较

冒泡排序

1. 思想：每次将最大的数字移动到数组的最后面。比较复杂度和操作复杂度都较高。
2. 代码实现

public static void bubbleSort(int[] arr)
   {
       int len = arr.length;
       for(int i=0;i<len-1;i++)
       {
           for(int j=0;j<len-i-1;j++)
           {
               if(arr[j]>arr[j+1])
               {
                   int tmp = arr[j];
                   arr[j] = arr[j+1];
                   arr[j+1] = tmp;
               }
           }
       }
   }

选择排序

1. 思想：假设每次最小值（最大值）为第一个，然后遍历之后的元素，若有更小的元素，则该元素的下标就为minIndex。最后，将最小的值换至第一个（i）位置。
2. 代码实现

public static void selectSort(int[] arr)
   {
       int len = arr.length;
       for(int i=0;i<len-1;i++)
       {
           int minIndex = i;
           for(int j=i+1;j<len;j++)
           {
               if(arr[j]<arr[minIndex])
                   minIndex = j;
           }
           if(minIndex!=i)
           {
               int tmp = arr[i];
               arr[i] = arr[minIndex];
               arr[minIndex] = tmp; 
           }           
       }
   }

插入排序

1. 思想：将数组分为有序和无须的两部分，每次从无须的数组中选出一个元素与有序数组进行比较，并将其插入到有序数组中。比较复杂度和操作复杂度都较小。
   * 每次必须记下无序数组的第一个值，便于后移和插入。
2. 代码实现

 public static void insertSort(int arr[])
   {
       for(int out = 1;out<arr.length;out++)
       {
           int in = out;
           int temp = arr[out];
           while(in>0&&arr[in-1]>temp)
           {
               arr[in] = arr[in-1];
               in--;
           }
           arr[in] = temp;
       }

   }

效率比较

 public static void main(String[] args) {
     int[] arr = new int[100000];
     for(int i=0;i<arr.length;i++)
     {
         arr[i] = (int)(Math.random()*100000);
     }
     long before = System.currentTimeMillis();
     insertSort(arr);
     // selectSort(arr);
     // bubbleSort(arr);
     long after = System.currentTimeMillis();
     System.out.println("执行时间是： "+(after-before));

最终结果（100000个元素的数组排序时间）

• 冒泡排序： 19446
• 选择排序： 5309
• 插入排序： 1589

最终结论显示，插入排序的效率要高于选择排序和冒泡排序。