用Java随机生成10000不含重复的整数，用插入排序对其从小到大排序并记录运行时间（分三种情况：有序，逆序，随机排序）

### 回答1：
您好，我可以回答您的问题。以下是我的回答：

使用Java可以通过Random类生成10000个不重复的整数，然后使用插入排序对其进行排序。对于有序、逆序和随机排序三种情况，插入排序的时间复杂度均为O(n^2)。具体实现代码如下：

import java.util.*;

public class InsertionSort {
    public static void main(String[] args) {
        int[] arr = generateRandomArray(10000);
        long startTime = System.currentTimeMillis();
        insertionSort(arr);
        long endTime = System.currentTimeMillis();
        System.out.println("随机排序运行时间：" + (endTime - startTime) + "ms");

        arr = generateSortedArray(10000);
        startTime = System.currentTimeMillis();
        insertionSort(arr);
        endTime = System.currentTimeMillis();
        System.out.println("有序排序运行时间：" + (endTime - startTime) + "ms");

        arr = generateReverseArray(10000);
        startTime = System.currentTimeMillis();
        insertionSort(arr);
        endTime = System.currentTimeMillis();
        System.out.println("逆序排序运行时间：" + (endTime - startTime) + "ms");
    }

    public static void insertionSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int temp = arr[i];
            int j = i - 1;
            while (j >=  && arr[j] > temp) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = temp;
        }
    }

    public static int[] generateRandomArray(int n) {
        Set<Integer> set = new HashSet<>();
        Random random = new Random();
        while (set.size() < n) {
            set.add(random.nextInt(n * 10));
        }
        int[] arr = new int[n];
        int i = ;
        for (int num : set) {
            arr[i++] = num;
        }
        return arr;
    }

    public static int[] generateSortedArray(int n) {
        int[] arr = new int[n];
        for (int i = ; i < n; i++) {
            arr[i] = i;
        }
        return arr;
    }

    public static int[] generateReverseArray(int n) {
        int[] arr = new int[n];
        for (int i = ; i < n; i++) {
            arr[i] = n - i;
        }
        return arr;
    }
}

希望我的回答能够帮助到您。

### 回答2：
首先，我们可以使用Java中的Random类来生成不重复的整数。为了确保不重复，我们可以将生成的整数存储在HashSet中，因为HashSet不允许重复的值。

import java.util.HashSet;
import java.util.Random;

public class Main {

    public static void main(String[] args) {
        HashSet<Integer> set = new HashSet<>();
        Random random = new Random();
        
        while(set.size() < 10000) {
            int num = random.nextInt(10000); // 生成范围为0到9999的整数
            set.add(num);
        }
        
        Integer[] arr = set.toArray(new Integer[set.size()]);
        
        // 对有序数组进行排序
        long startTime = System.nanoTime();
        insertionSort(arr);
        long endTime = System.nanoTime();
        long duration1 = endTime - startTime;
        
        // 对逆序数组进行排序
        reverseArray(arr);
        startTime = System.nanoTime();
        insertionSort(arr);
        endTime = System.nanoTime();
        long duration2 = endTime - startTime;
        
        // 对随机排序数组进行排序
        randomizeArray(arr);
        startTime = System.nanoTime();
        insertionSort(arr);
        endTime = System.nanoTime();
        long duration3 = endTime - startTime;
        
        System.out.println("有序数组的运行时间：" + duration1 + "纳秒");
        System.out.println("逆序数组的运行时间：" + duration2 + "纳秒");
        System.out.println("随机排序数组的运行时间：" + duration3 + "纳秒");
    }
    
    public static void insertionSort(Integer[] arr) {
        int n = arr.length;
        
        for (int i = 1; i < n; ++i) {
            int key = arr[i];
            int j = i - 1;
            
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j = j - 1;
            }
            
            arr[j + 1] = key;
        }
    }
    
    public static void reverseArray(Integer[] arr) {
        int n = arr.length;
        
        for (int i = 0; i < n / 2; ++i) {
            int temp = arr[i];
            arr[i] = arr[n - i - 1];
            arr[n - i - 1] = temp;
        }
    }
    
    public static void randomizeArray(Integer[] arr) {
        Random random = new Random();
        
        for (int i = 0; i < arr.length; ++i) {
            int randomIndex = random.nextInt(arr.length);
            int temp = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = temp;
        }
    }
}

上述代码中，我们使用了`insertionSort`方法来实现插入排序算法，`reverseArray`方法将数组反转，`randomizeArray`方法将数组随机化。

通过生成包含10000个不重复整数的HashSet，我们将这些整数转换为数组，并进行三次排序（有序，逆序，随机排序）。然后，我们使用`System.nanoTime()`函数记录排序的起始时间和结束时间，计算运行时间。最后，我们输出每种排序情况下的运行时间。

这个程序使用插入排序来对10000个整数进行排序，可以方便地了解插入排序在不同情况下的性能差异，以及排序的运行时间。

### 回答3：
首先，我们可以使用Java的Random类来生成10000个不重复的整数。
以下是生成不重复整数的代码示例：

import java.util.Random;
import java.util.HashSet;

public class RandomIntegerGenerator {
    public static void main(String[] args) {
        Random random = new Random();
        HashSet<Integer> set = new HashSet<>();
        int count = 0;
        
        while (count < 10000) {
            int num = random.nextInt(100000);
            if (!set.contains(num)) {
                set.add(num);
                count++;
            }
        }
        
        // 将生成的不重复整数存储在一个数组中
        Integer[] arr = set.toArray(new Integer[0]);
        
        // 排序并计算运行时间
        long startTime = System.currentTimeMillis();
        insertSort(arr);
        long endTime = System.currentTimeMillis();
        long elapsedTime = endTime - startTime;
        
        System.out.println("运行时间：" + elapsedTime + " 毫秒");
    }
    
    public static void insertSort(Integer[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int key = arr[i];
            int j = i - 1;
            
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            
            arr[j + 1] = key;
        }
    }
}

接下来，我们可以分别测试有序、逆序和随机排序三种情况。

1. 有序排序：

Integer[] arr = new Integer[10000];
for (int i = 0; i < 10000; i++) {
    arr[i] = i;
}

2. 逆序排序：

Integer[] arr = new Integer[10000];
for (int i = 0; i < 10000; i++) {
    arr[i] = 10000 - i - 1;
}

3. 随机排序：无需做任何改动，原始的代码已经生成了随机排序的整数数组。

运行以上代码后，将会输出排序的时间，单位为毫秒。