JAVA 实现五种基本排序方法的实现以及时间的统计

package test;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
public class sort {
  /**
   *Author:April
   *Date:2018.12.1
   *Version:0.1
   *Description:1、选择排序、冒泡排序、归并排序、快速排序、插入排序的算法原理。
   *            2.不同排序算法时间效率的经验分析方法，验证理论分析与经验分析的一致性。
   *
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    func();   
  }
  private static void func() {
    // TODO Auto-generated method stub
    System.out.println("1.选择排序 2.冒泡排序 3.合并排序 4.快速排序  5.插入排序");
    @SuppressWarnings("resource")
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入要选择的字母：");
    int num = sc.nextInt();
    //int num  = sc.nextInt();
    switch(num){
    case 1:
      //System.out.println("1");
        select();
      break;
    case 2:
      bubble();
      break;
    case 3:
      merge();
      break;
    case 4:
      fast();
      break;
    case 5:
      insert();
      break;
    default:
      System.out.println("请输入正确的字母");
    }
  }
//插入排序
  private static void insert() {
    // TODO Auto-generated method stub
    //数据规模为10时
    double begin = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
    int[] nums = new int[10];  //定义一个一维数组
      int count=0;
      while(count<10) {
       nums[count]=(int)(Math.random()*100);//产生100以内的随机数给nums
       count++;
      }
      //插入排序
      int insertNote;
      for (int i = 1; i < nums.length; i++) {// 从数组的第二个元素开始循环将数组中的元素插入
              insertNote = nums[i];// 设置数组中的第2个元素为第一次循环要插入的数据
              int j = i - 1;
              while ( j >= 0 && insertNote < nums[j]) {
                nums[j + 1] = nums[j];// 如果要插入的元素小于第j个元素,就将第j个元素向后移动
                  j--;
              }
              nums[j + 1] = insertNote;// 直到要插入的元素不小于第j个元素,将insertNote插入到数组中
          }
      System.out.println("数据规模为"+nums.length+"时");//数组长度
      System.out.println("排序后序列为：");
      for (int i = 0; i < nums.length; i++) {   //循环并打印出每个数组的数字
       System.out.print(nums[i]+"\t") ;
       }
      double end = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
      double time = end - begin;// 程序的运行时间    
      System.out.println("\n排序所花平均时间(ms)："+time / 60*1000 );
//数据规模为100时   
      double begin1 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
      int[] nums1 = new int[100];  //定义一个一维数组
        int count1=0;
        while(count1<100) {
         nums1[count1]=(int)(Math.random()*100);//产生100以内的随机数给nums
         count1++;
        }
        //插入排序
        int insertNote1;
        for (int i = 1; i < nums.length; i++) {// 从数组的第二个元素开始循环将数组中的元素插入
                insertNote1 = nums[i];// 设置数组中的第2个元素为第一次循环要插入的数据
                int j = i - 1;
                while ( j >= 0 && insertNote1 < nums[j]) {
                  nums[j + 1] = nums[j];// 如果要插入的元素小于第j个元素,就将第j个元素向后移动
                    j--;
                }
                nums[j + 1] = insertNote1;// 直到要插入的元素不小于第j个元素,将insertNote插入到数组中
            }
        System.out.println("数据规模为"+nums1.length+"时");//数组长度
        System.out.println("排序后序列为：");
        for (int i = 0; i < nums1.length; i++) {   //循环并打印出每个数组的数字
         System.out.print(nums1[i]+"\t") ;
         }
        double end1 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
        double time1 = end1 - begin1;// 程序的运行时间   
        System.out.println("\n排序所花平均时间(ms)："+time1 / 60*1000 );
//数据规模为1000时
        double begin2 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
        int[] nums2 = new int[1000];  //定义一个一维数组
          int count2=0;
          while(count2<1000) {
            nums2[count2]=(int)(Math.random()*100);//产生100以内的随机数给nums
            count2++;
          }
          //插入排序
          int insertNote2;
          for (int i = 1; i < nums.length; i++) {// 从数组的第二个元素开始循环将数组中的元素插入
                  insertNote2 = nums[i];// 设置数组中的第2个元素为第一次循环要插入的数据
                  int j = i - 1;
                  while ( j >= 0 && insertNote2 < nums[j]) {
                    nums[j + 1] = nums[j];// 如果要插入的元素小于第j个元素,就将第j个元素向后移动
                      j--;
                  }
                  nums[j + 1] = insertNote2;// 直到要插入的元素不小于第j个元素,将insertNote插入到数组中
              }
          System.out.println("数据规模为"+nums2.length+"时");//数组长度
          System.out.println("排序后序列为：");
          for (int i = 0; i < nums2.length; i++) {   //循环并打印出每个数组的数字
           System.out.print(nums2[i]+"\t") ;
           }
          double end2 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
          double time2 = end2 - begin2;// 程序的运行时间   
          System.out.println("\n排序所花平均时间(ms)："+time2 / 60*1000 );
//数据规模为10000时
          double begin3 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
          int[] nums3 = new int[10000];  //定义一个一维数组
            int count3=0;
            while(count3<10000) {
              nums3[count3]=(int)(Math.random()*100);//产生100以内的随机数给nums
              count3++;
            }
            //插入排序
            int insertNote3;
            for (int i = 1; i < nums.length; i++) {// 从数组的第二个元素开始循环将数组中的元素插入
                    insertNote3 = nums[i];// 设置数组中的第2个元素为第一次循环要插入的数据
                    int j = i - 1;
                    while ( j >= 0 && insertNote3 < nums[j]) {
                      nums[j + 1] = nums[j];// 如果要插入的元素小于第j个元素,就将第j个元素向后移动
                        j--;
                    }
                    nums[j + 1] = insertNote3;// 直到要插入的元素不小于第j个元素,将insertNote插入到数组中
                }
            System.out.println("数据规模为"+nums3.length+"时");//数组长度
            System.out.println("排序后序列为：");
            for (int i = 0; i < nums3.length; i++) {   //循环并打印出每个数组的数字
             System.out.print(nums3[i]+"\t") ;
             }
            double end3 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
            double time3 = end3 - begin3;// 程序的运行时间   
            System.out.println("\n排序所花平均时间(ms)："+time3 / 60*1000 );
//数据规模为100000时
            double begin4 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
            int[] nums4 = new int[100000];  //定义一个一维数组
              int count4=0;
              while(count4<100000) {
                nums4[count4]=(int)(Math.random()*100);//产生100以内的随机数给nums
                count4++;
              }
              //插入排序
              int insertNote4;
              for (int i = 1; i < nums.length; i++) {// 从数组的第二个元素开始循环将数组中的元素插入
                      insertNote4 = nums[i];// 设置数组中的第2个元素为第一次循环要插入的数据
                      int j = i - 1;
                      while ( j >= 0 && insertNote4 < nums[j]) {
                        nums[j + 1] = nums[j];// 如果要插入的元素小于第j个元素,就将第j个元素向后移动
                          j--;
                      }
                      nums[j + 1] = insertNote4;// 直到要插入的元素不小于第j个元素,将insertNote插入到数组中
                  }
              System.out.println("数据规模为"+nums4.length+"时");//数组长度
//              System.out.println("排序后序列为：");
//              for (int i = 0; i < nums4.length; i++) {   //循环并打印出每个数组的数字
//               System.out.print(nums4[i]+"\t") ;
//               }
              double end4 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
              double time4 = end4 - begin4;// 程序的运行时间   
              System.out.println("\n排序所花平均时间(ms)："+time4 / 60*1000 );
  }
//快速排序
  private static void fast() {
    // TODO Auto-generated method stub
  }
//合并排序
  private static void merge() {
    // TODO Auto-generated method stub
  }
//冒泡排序
  private static void bubble() {
    // TODO Auto-generated method stub
    //数据规模为10时
    double begin = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
    int[] nums = new int[10];  //定义一个一维数组
      int count=0;
      while(count<10) {
       nums[count]=(int)(Math.random()*100);//产生100以内的随机数给nums
       count++;
      }
      //冒泡排序
    for (int i = 0; i < nums.length - 1; i++) {// 外层循环控制排序趟数
      for (int j = 0; j < nums.length - 1 - i; j++) {// 内层循环控制每一趟排序多少次
        if (nums[j] > nums[j + 1]) {
          int temp = nums[j];
          nums[j] = nums[j + 1];
          nums[j + 1] = temp;
        }
      }
    }
      System.out.println("数据规模为"+nums.length+"时");//数组长度
      System.out.println("排序后序列为：");
      for (int i = 0; i < nums.length; i++) {   //循环并打印出每个数组的数字
       System.out.print(nums[i]+"\t") ;
       }
      double end = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
      double time = end - begin;// 程序的运行时间    
      System.out.println("\n排序所花平均时间(ms)："+time / 60*1000 );
//数据规模为100时   
      double begin1 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
      int[] nums1 = new int[100];  //定义一个一维数组
        int count1=0;
        while(count1<100) {
         nums1[count1]=(int)(Math.random()*100);//产生100以内的随机数给nums
         count1++;
        }
        //冒泡排序
        for (int i = 0; i < nums.length - 1; i++) {// 外层循环控制排序趟数
          for (int j = 0; j < nums.length - 1 - i; j++) {// 内层循环控制每一趟排序多少次
            if (nums[j] > nums[j + 1]) {
              int temp = nums[j];
              nums[j] = nums[j + 1];
              nums[j + 1] = temp;
            }
          }
        }
        System.out.println("数据规模为"+nums1.length+"时");//数组长度
        System.out.println("排序后序列为：");
        for (int i = 0; i < nums1.length; i++) {   //循环并打印出每个数组的数字
         System.out.print(nums1[i]+"\t") ;
         }
        double end1 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
        double time1 = end1 - begin1;// 程序的运行时间   
        System.out.println("\n排序所花平均时间(ms)："+time1 / 60*1000 );
//数据规模为1000时
        double begin2 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
        int[] nums2 = new int[1000];  //定义一个一维数组
          int count2=0;
          while(count2<1000) {
            nums2[count2]=(int)(Math.random()*100);//产生100以内的随机数给nums
            count2++;
          }
          //冒泡排序
          //冒泡排序
          for (int i = 0; i < nums.length - 1; i++) {// 外层循环控制排序趟数
            for (int j = 0; j < nums.length - 1 - i; j++) {// 内层循环控制每一趟排序多少次
              if (nums[j] > nums[j + 1]) {
                int temp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = temp;
              }
            }
          }
          System.out.println("数据规模为"+nums2.length+"时");//数组长度
          System.out.println("排序后序列为：");
          for (int i = 0; i < nums2.length; i++) {   //循环并打印出每个数组的数字
           System.out.print(nums2[i]+"\t") ;
           }
          double end2 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
          double time2 = end2 - begin2;// 程序的运行时间   
          System.out.println("\n排序所花平均时间(ms)："+time2 / 60*1000 );
//数据规模为10000时
          double begin3 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
          int[] nums3 = new int[10000];  //定义一个一维数组
            int count3=0;
            while(count3<10000) {
              nums3[count3]=(int)(Math.random()*100);//产生100以内的随机数给nums
              count3++;
            }
            //冒泡排序
            //冒泡排序
            for (int i = 0; i < nums.length - 1; i++) {// 外层循环控制排序趟数
              for (int j = 0; j < nums.length - 1 - i; j++) {// 内层循环控制每一趟排序多少次
                if (nums[j] > nums[j + 1]) {
                  int temp = nums[j];
                  nums[j] = nums[j + 1];
                  nums[j + 1] = temp;
                }
              }
            }
            System.out.println("数据规模为"+nums3.length+"时");//数组长度
            System.out.println("排序后序列为：");
            for (int i = 0; i < nums3.length; i++) {   //循环并打印出每个数组的数字
             System.out.print(nums3[i]+"\t") ;
             }
            double end3 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
            double time3 = end3 - begin3;// 程序的运行时间   
            System.out.println("\n排序所花平均时间(ms)："+time3 / 60*1000 );
//数据规模为100000时
            double begin4 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
            int[] nums4 = new int[100000];  //定义一个一维数组
              int count4=0;
              while(count4<100000) {
                nums4[count4]=(int)(Math.random()*100);//产生100以内的随机数给nums
                count4++;
              }
              //冒泡排序
              for (int i = 0; i < nums.length - 1; i++) {// 外层循环控制排序趟数
                for (int j = 0; j < nums.length - 1 - i; j++) {// 内层循环控制每一趟排序多少次
                  if (nums[j] > nums[j + 1]) {
                    int temp = nums[j];  //temp是用于交换时的临时变量
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                  }
                }
              }
              System.out.println("数据规模为"+nums4.length+"时");//数组长度
//              System.out.println("排序后序列为：");
//              for (int i = 0; i < nums4.length; i++) {   //循环并打印出每个数组的数字
//               System.out.print(nums4[i]+"\t") ;
//               }
              double end4 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
              double time4 = end4 - begin4;// 程序的运行时间   
              System.out.println("\n排序所花平均时间(ms)："+time4 / 60*1000 );
  }
//选择排序
  private static void select() {  
    // TODO Auto-generated method stub
    //数据规模为10时
    double begin = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
    int[] nums = new int[10];  //定义一个一维数组
      int count=0;
      while(count<10) {
       nums[count]=(int)(Math.random()*100);//产生100以内的随机数给nums
       count++;
      }
      //选择排序
      for(int i = 0; i < nums.length-1; ++i){  //外层循环数组寻找最小的数
              int k = i;
              for(int j = i; j < nums.length; ++j){  //内层循环，做比较
                  if(nums[k] > nums[j]){  //若j比k小，则把j放入前面的位置
                      k = j;
                  }
              }
              if(k != i){  //交换元素
                  int temp = nums[i];  //temp是用于交换时的临时变量
                  nums[i] = nums[k];
                  nums[k] = temp;
              }
          }
      System.out.println("数据规模为"+nums.length+"时");//数组长度
      System.out.println("排序后序列为：");
      for (int i = 0; i < nums.length; i++) {   //循环并打印出每个数组的数字
       System.out.print(nums[i]+"\t") ;
       }
      double end = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
      double time = end - begin;// 程序的运行时间    
      System.out.println("\n排序所花平均时间(ms)："+time / 60*1000 );
//数据规模为100时   
      double begin1 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
      int[] nums1 = new int[100];  //定义一个一维数组
        int count1=0;
        while(count1<100) {
         nums1[count1]=(int)(Math.random()*100);//产生100以内的随机数给nums
         count1++;
        }
        //选择排序
        for(int i = 0; i < nums1.length-1; ++i){  //外层循环数组寻找最小的数
                int k = i;
                for(int j = i; j < nums1.length; ++j){  //内层循环，做比较
                    if(nums1[k] > nums1[j]){  //若j比k小，则把j放入前面的位置
                        k = j;
                    }
                }
                if(k != i){  //交换元素
                    int temp = nums1[i];  //temp是用于交换时的临时变量
                    nums1[i] = nums1[k];
                    nums1[k] = temp;
                }
            }
        System.out.println("数据规模为"+nums1.length+"时");//数组长度
        System.out.println("排序后序列为：");
        for (int i = 0; i < nums1.length; i++) {   //循环并打印出每个数组的数字
         System.out.print(nums1[i]+"\t") ;
         }
        double end1 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
        double time1 = end1 - begin1;// 程序的运行时间   
        System.out.println("\n排序所花平均时间(ms)："+time1 / 60*1000 );
//数据规模为1000时
        double begin2 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
        int[] nums2 = new int[1000];  //定义一个一维数组
          int count2=0;
          while(count2<1000) {
            nums2[count2]=(int)(Math.random()*100);//产生100以内的随机数给nums
            count2++;
          }
          //选择排序
          for(int i = 0; i < nums2.length-1; ++i){  //外层循环数组寻找最小的数
                  int k = i;
                  for(int j = i; j < nums2.length; ++j){  //内层循环，做比较
                      if(nums2[k] > nums2[j]){  //若j比k小，则把j放入前面的位置
                          k = j;
                      }
                  }
                  if(k != i){  //交换元素
                      int temp = nums2[i];  //temp是用于交换时的临时变量
                      nums2[i] = nums2[k];
                      nums2[k] = temp;
                  }
              }
          System.out.println("数据规模为"+nums2.length+"时");//数组长度
          System.out.println("排序后序列为：");
          for (int i = 0; i < nums2.length; i++) {   //循环并打印出每个数组的数字
           System.out.print(nums2[i]+"\t") ;
           }
          double end2 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
          double time2 = end2 - begin2;// 程序的运行时间   
          System.out.println("\n排序所花平均时间(ms)："+time2 / 60*1000 );
//数据规模为10000时
          double begin3 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
          int[] nums3 = new int[10000];  //定义一个一维数组
            int count3=0;
            while(count3<10000) {
              nums3[count3]=(int)(Math.random()*100);//产生100以内的随机数给nums
              count3++;
            }
            //选择排序
            for(int i = 0; i < nums3.length-1; ++i){  //外层循环数组寻找最小的数
                    int k = i;
                    for(int j = i; j < nums3.length; ++j){  //内层循环，做比较
                        if(nums3[k] > nums3[j]){  //若j比k小，则把j放入前面的位置
                            k = j;
                        }
                    }
                    if(k != i){  //交换元素
                        int temp = nums3[i];  //temp是用于交换时的临时变量
                        nums3[i] = nums3[k];
                        nums3[k] = temp;
                    }
                }
            System.out.println("数据规模为"+nums3.length+"时");//数组长度
            System.out.println("排序后序列为：");
            for (int i = 0; i < nums3.length; i++) {   //循环并打印出每个数组的数字
             System.out.print(nums3[i]+"\t") ;
             }
            double end3 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
            double time3 = end3 - begin3;// 程序的运行时间   
            System.out.println("\n排序所花平均时间(ms)："+time3 / 60*1000 );
//数据规模为100000时
            double begin4 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
            int[] nums4 = new int[100000];  //定义一个一维数组
              int count4=0;
              while(count4<100000) {
                nums4[count4]=(int)(Math.random()*100);//产生100以内的随机数给nums
                count4++;
              }
              //选择排序
              for(int i = 0; i < nums4.length-1; ++i){  //外层循环数组寻找最小的数
                      int k = i;
                      for(int j = i; j < nums4.length; ++j){  //内层循环，做比较
                          if(nums4[k] > nums4[j]){  //若j比k小，则把j放入前面的位置
                              k = j;
                          }
                      }
                      if(k != i){  //交换元素
                          int temp = nums4[i];  //temp是用于交换时的临时变量
                          nums4[i] = nums4[k];
                          nums4[k] = temp;
                      }
                  }
              System.out.println("数据规模为"+nums4.length+"时");//数组长度
//              System.out.println("排序后序列为：");
//              for (int i = 0; i < nums4.length; i++) {   //循环并打印出每个数组的数字
//               System.out.print(nums4[i]+"\t") ;
//               }
              double end4 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
              double time4 = end4 - begin4;// 程序的运行时间   
              System.out.println("\n排序所花平均时间(ms)："+time4 / 60*1000 );
  }
}