0、工具类SortHelper

/**
* 排序相关的辅助类
*/
public class SortHelper {

  private SortHelper() {
  }

  /**
   * 生成一个数组长度为n的随机数组，每个元素的范围为[rangeL, rangeR]
   * 
   * @param n
   * @param rangeL
   * @param rangeR
   * @return
   */
  public static Integer[] generateRandomArray(int n, int rangeL, int rangeR) {
    assert rangeL <= rangeR;

    Integer[] arr = new Integer[n];
    for (int i = 0; i < n; i++) {
      arr[i] = new Integer((int) (Math.random() * (rangeR - rangeL + 1) + rangeL));
    }
    return arr;
  }

  /**
   * 1、生成一个数组长度为n的近乎有序数组；
   * 2、swapTimes定义了数组的无序程度：当swapTimes==0时，数组完全有序；swapTimes越大，数组越趋向于无序。
   * 
   * @param n
   * @param swapTimes
   * @return
   */
  public static Integer[] generateNearlyOrderedArray(int n, int swapTimes) {

    // 首先生成一个含有[0……n-1]的完成有序数组，之后随即交换swapTimes对数据。
    Integer[] arr = new Integer[n];
    for (int i = 0; i < n; i++) {
      arr[i] = new Integer(i);
    }

    for (int i = 0; i < swapTimes; i++) {
      int a = (int) (Math.random() * n);
      int b = (int) (Math.random() * n);
      swap(arr, a, b);
    }

    return arr;
  }

  /**
   * 判断一个数组是否有序
   * 
   * @param arr
   * @return
   */
  public static boolean isSorted(Comparable[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
      if (arr[i].compareTo(arr[i + 1]) > 0) {
        return false;
      }
    }
    return true;
  }

  /**
   * 测试sortClassName所对应的排序算法排序arr数组所得到的正确性和算法运行时间（默认不打印排序后数组）
   * 
   * @param sortClassName
   * @param methodName
   * @param arr
   */
  public static void testSort(String sortClassName, String methodName, Comparable[] arr) {
    testSort(sortClassName, methodName, arr, false);
  }

  /**
   * 测试sortClassName所对应的排序算法排序arr数组所得到的正确性和算法运行时间
   * 
   * @param sortClassName
   * @param methodName
   * @param arr
   * @param print
   *          是否打印排序后的数组
   */
  public static void testSort(String sortClassName, String methodName, Comparable[] arr,
      boolean print) {
    // 通过Java的反射机制，通过排序的类名，运行排序函数
    try {
      // 通过sortClassName获得排序函数的Class对象
      Class sortClass = Class.forName(sortClassName);
      // 通过排序函数的Class对象获得排序方法
      Method sortMethod = sortClass.getMethod(methodName, new Class[] {
        Integer[].class });
      // 排序参数只有一个，是可比较数组arr
      Object[] params = new Object[] {
        arr };

      long startTime = System.currentTimeMillis();
      // 调用排序函数
      Integer[] result = (Integer[]) sortMethod.invoke(null, params);
      long endTime = System.currentTimeMillis();

      assert isSorted(arr);
      if (print) {
        SortHelper.printArr("排序后数组：", result);
      }
      System.out.println(sortClass.getSimpleName() + "->" + methodName + "用时: "
          + (endTime - startTime) + "ms");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  /**
   * 打印数组中的每个元素
   * 
   * @param title
   * @param arr
   */
  public static void printArr(String title, Integer[] arr) {
    System.out.println(title);
    for (int i = 0; i < arr.length; i++) {
      System.out.print(arr[i] + (i == arr.length - 1 ? "" : ","));
    }
    System.out.println();
  }

  /**
   * 交换数组中两个位置的值，第j个位置的数和第i个位置的数进行交换位置
   * 
   * @param arr
   *          要交换的数组
   * @param i
   *          要交换的位置
   * @param j
   *          待交转的位置
   */
  public static void swap(Integer[] arr, int i, int j) {
    Integer temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
  }
}

 

转载于:https://my.oschina.net/u/3550572/blog/978918