用java写出直接选择排序，堆排序的代码，并设置50个以上数组元素，验证哪个算法用时最短

好的，以下是直接选择排序和堆排序的 Java 代码：

直接选择排序：

public static void selectionSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n-1; i++) {
        int minIndex = i;
        for (int j = i+1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        int temp = arr[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
    }
}

堆排序：

public static void heapSort(int[] arr) {
    int n = arr.length;
    for (int i = n/2-1; i >= 0; i--) {
        heapify(arr, n, i);
    }
    for (int i = n-1; i > 0; i--) {
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        heapify(arr, i, 0);
    }
}

public static void heapify(int[] arr, int n, int i) {
    int largest = i;
    int l = 2*i+1;
    int r = 2*i+2;
    if (l < n && arr[l] > arr[largest]) {
        largest = l;
    }
    if (r < n && arr[r] > arr[largest]) {
        largest = r;
    }
    if (largest != i) {
        int temp = arr[i];
        arr[i] = arr[largest];
        arr[largest] = temp;
        heapify(arr, n, largest);
    }
}

为了验证哪个算法用时最短，我们可以设置一个长度为 50 的随机数组，然后分别对该数组进行直接选择排序和堆排序，记录下两个算法的运行时间，最后比较哪个算法的运行时间更短。

下面是测试代码：

public static void main(String[] args) {
    int[] arr = new int[50];
    Random random = new Random();
    for (int i = 0; i < arr.length; i++) {
        arr[i] = random.nextInt(100);
    }

    long start = System.nanoTime();
    selectionSort(arr);
    long end = System.nanoTime();
    long time1 = end - start;

    start = System.nanoTime();
    heapSort(arr);
    end = System.nanoTime();
    long time2 = end - start;

    System.out.println("直接选择排序用时：" + time1 + "纳秒");
    System.out.println("堆排序用时：" + time2 + "纳秒");

    if (time1 < time2) {
        System.out.println("直接选择排序更快！");
    } else if (time1 > time2) {
        System.out.println("堆排序更快！");
    } else {
        System.out.println("两种算法用时相同！");
    }
}

注意，由于每次运行的时间可能有所不同，所以最好多次运行并取平均值来比较两种算法的运行时间。