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

冒泡排序

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

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