经典算法分析：n^2与nlgn

冒泡、插入、选择排序的时间复杂度为O（n²）

Arrays.sort()时间复杂度为nlgn

具体算法实现代码：

  1 package recursion;
  2 
  3 import java.util.Arrays;
  4 
  5 /**
  6  * @author zsh
  7  * @company wlgzs
  8  * @create 2019-02-17 9:46
  9  * @Describe 冒泡、插入、选择排序与Arrays.sort()的性能差别
 10  */
 11 public class Main3 {
 12 
 13     /**
 14      * 冒泡排序
 15      * @param arr 待排序的数组
 16      * @return 已排序的数组
 17      */
 18     static int[] bubbleSort(int[] arr){
 19         //外层循环执行N-1趟
 20         for (int i = 0; i < arr.length -1; i++) {
 21             //内层循环执行N-1-i趟
 22             for (int j = 0; j < arr.length -1 -i ; j++) {
 23                 //如果数组前一个元素比后一个元素的值大，交换
 24                 if (arr[j] > arr[j+1]){
 25                     int temp = arr[j+1];
 26                     arr[j+1] = arr[j];
 27                     arr[j] = temp;
 28                 }
 29             }
 30         }
 31         return arr;
 32     }
 33 
 34     /**
 35      * insertSort(arr,k) 递归实现插入排序
 36      * 找重复：insertSort(arr,k-1) 将k-1个排序后，把arr[k]插入到前面的数据中 --子问题
 37      * 找变化：变化的量应该作为参数 k。
 38      * 找边界：出口 终止的条件 k == 0
 39      */
 40     static int[] insertSort(int[] arr,int k){
 41         if (k == 0){
 42             return arr;
 43         }
 44         //对前k-1个元素排序
 45         insertSort(arr,k-1);
 46         //把k位置上的元素插入到前面的部分
 47         int x = arr[k];
 48         int index = k -1;
 49         while (index >= 0 && x <arr[index]){
 50             arr[index+1] = arr[index];
 51             index--;
 52         }
 53         arr[index+1] = x;
 54         return arr;
 55     }
 56 
 57 
 58     /**
 59      * 选择排序
 60      * @param arr 待排序的数组
 61      * @return 已排序的数组
 62      */
 63     static int[] selectionSort(int[] arr){
 64         for (int i = 0; i < arr.length-1; i++) {
 65             int k = i;
 66             for (int j = i + 1; j < arr.length ; j++) {
 67                 if (arr[j] < arr[k]){
 68                     //记录此时找到最小值的位置
 69                     k = j;
 70                 }
 71             }
 72             //内层循环结束，找到最小值后进行交换
 73             if (i != k){
 74                 int temp = arr[i];
 75                 arr[i] = arr[k];
 76                 arr[k] = temp;
 77             }
 78         }
 79         return arr;
 80     }
 81 
 82     public static void main(String[] args) {
 83         //构造随机数组
 84         int[] arr = new int[10000];
 85         for (int i = 0; i < arr.length; i++) {
 86             double a = Math.random()*10000;
 87             arr[i] = (int) a;
 88         }
 89         //调用冒泡排序进行
 90         long time1 = System.currentTimeMillis();
 91         System.out.println(Arrays.toString(bubbleSort(arr)));
 92         long time2 = System.currentTimeMillis();
 93         System.out.println(time2-time1+"ms");
 94         //调用插入排序进行(使用递归)
 95         long time3 = System.currentTimeMillis();
 96         System.out.println(Arrays.toString(insertSort(arr,arr.length-1)));
 97         long time4 = System.currentTimeMillis();
 98         System.out.println(time4-time3+"ms");
 99         //调用选择排序进行
100         long time5 = System.currentTimeMillis();
101         System.out.println(Arrays.toString(selectionSort(arr)));
102         long time6 = System.currentTimeMillis();
103         System.out.println(time6-time5+"ms");
104         //调用Arrays.sort()进行
105         long time7 = System.currentTimeMillis();
106         Arrays.sort(arr);
107         long time8 = System.currentTimeMillis();
108         System.out.println(Arrays.toString(arr));
109         System.out.println(time8-time7+"ms");
110     }
111 
112 }

控制台输出：

 

转载于:https://www.cnblogs.com/zsh-blogs/p/10390333.html