给数组随机存入不同的整数

好的，这个问题是一个计算机编程问题，我可以回答。如果要随机存入不同的整数，可以使用一个集合（Set）来存储已经存入的数字，每次生成一个随机数时，先判断这个数字是否已经存在于集合中，如果不存在，则将它加入集合并存入数组中。如果已经存在，则重新生成一个新的随机数，直到生成的随机数不在集合中为止。这样就可以保证每个数字只会出现一次。

相关问题

Java数组随机产生100个大于等于1，小于10000的随机整数存入整数数组intArr[]中，用冒泡升序排序和二分法逆序排序算法进行排序

### 回答1：
可以使用Java的`Random`类来产生随机数，例如：

import java.util.Random;

int[] intArr = new int[100];
Random rand = new Random();
for (int i = 0; i < intArr.length; i++) {
  intArr[i] = rand.nextInt(9999) + 1;
}

要使用冒泡升序排序算法对数组进行排序，可以使用以下代码：

for (int i = 0; i < intArr.length - 1; i++) {
  for (int j = 0; j < intArr.length - i - 1; j++) {
    if (intArr[j] > intArr[j + 1]) {
      int temp = intArr[j];
      intArr[j] = intArr[j + 1];
      intArr[j + 1] = temp;
    }
  }
}

要使用二分法逆序排序算法对数组进行排序，可以使用以下代码：

import java.util.Arrays;

int[] intArr = new int[100];
Random rand = new Random();
for (int i = 0; i < intArr.length; i++) {
  intArr[i] = rand.nextInt(9999) + 1;
}
Arrays.sort(intArr, Collections.reverseOrder());

请注意，上述代码使用了Java的`Arrays.sort`方法和`Collections.reverseOrder`方法来实现逆序排序。

### 回答2：
首先，我们可以使用Java的Random类来生成100个大于等于1，小于10000的随机整数，然后将它们存入整数数组intArr[]中。

下面是实现该过程的代码：

import java.util.Arrays;
import java.util.Random;

public class ArraySort {
    public static void main(String[] args) {
        int[] intArr = new int[100];
        
        Random random = new Random();
        for (int i = 0; i < intArr.length; i++) {
            intArr[i] = random.nextInt(9999) + 1;
        }
        
        // 冒泡升序排序
        bubbleSort(intArr);
        
        // 二分法逆序排序
        binarySort(intArr);
    }
    
    // 冒泡升序排序算法
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println("冒泡升序排序结果：" + Arrays.toString(arr));
    }
    
    // 二分法逆序排序算法
    public static void binarySort(int[] arr) {
        // 先进行升序排序
        bubbleSort(arr);
        
        // 再逆序排列
        for (int i = 0; i < arr.length / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
        System.out.println("二分法逆序排序结果：" + Arrays.toString(arr));
    }
}

以上代码中，我们使用冒泡排序算法对数组进行升序排序，然后将排序后的数组传给二分法逆序排序算法，先进行升序排序，再将结果逆序排列。最后打印出排序结果。

要注意的是，在二分法逆序排序算法中，我们调用了冒泡排序算法来进行升序排序。这是因为在二分法逆序排序中，我们需要先进行升序排序，然后再将结果逆序排列。

### 回答3：
为了解决这个问题，我们可以用Java编写代码来实现。

首先,我们可以使用Math类的random()方法来生成随机整数。我们需要循环100次，每次生成一个介于1到9999之间的随机整数，并将其存储在intArr[]数组中。

int[] intArr = new int[100];
for (int i = 0; i < 100; i++) {
    intArr[i] = (int) (Math.random() * 9999) + 1;
}

接下来，我们使用冒泡排序算法对intArr[]数组进行升序排序。冒泡排序算法每次从头开始比较相邻的两个元素，并将较大的元素交换到后面。重复多次比较和交换的过程，直到所有元素都按照升序排列。

for (int i = 0; i < intArr.length - 1; i++) {
    for (int j = 0; j < intArr.length - i - 1; j++) {
        if (intArr[j] > intArr[j + 1]) {
            int temp = intArr[j];
            intArr[j] = intArr[j + 1];
            intArr[j + 1] = temp;
        }
    }
}

最后，我们使用二分法逆序排序算法对intArr[]数组进行逆序排序。二分法逆序排序算法是一种基于比较的排序方法，它通过不断地将待排序序列二分，然后将较大的元素交换到较小的元素前面，从而实现逆序排序。

for (int i = 1; i < intArr.length; i++) {
    int key = intArr[i];
    int low = 0;
    int high = i - 1;
    while (low <= high) {
        int mid = (low + high) / 2;
        if (key > intArr[mid]) {
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }
    for (int j = i; j > low; j--) {
        intArr[j] = intArr[j - 1];
    }
    intArr[low] = key;
}

通过以上代码，我们可以生成100个大于等于1、小于10000的随机整数，并使用冒泡排序和二分法逆序排序算法对其进行排序。

用java来解决声明一个具有10个元素的整型数组，随机生成10个整数并存入该数组中，求其最大值和最小值并输出。(不用课本实例的方法) 声明一个具有10个元素的整型数组，随机生成10个整数并存入该数组中，求其最大值和最小值并输出。

在Java中，可以使用`Random`类和`nextInt()`方法来生成随机数，并利用循环来填充数组、存储最大值和最小值。这里是一个非传统方法的示例，它直接在一个步骤中完成所有操作：

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        // 创建一个长度为10的整型数组
        int[] array = new int[10];
        
        // 初始化最大值和最小值为数组的第一个元素
        int max = array[0];
        int min = array[0];

        // 使用Random类创建一个随机数生成器
        Random random = new Random();

        // 循环10次生成随机数并存入数组，同时更新最大值和最小值
        for (int i = 0; i < array.length; i++) {
            int randomNumber = random.nextInt();  // 生成0到Integer.MAX_VALUE之间的随机整数
            array[i] = randomNumber;

            if (randomNumber > max) {
                max = randomNumber;
            } else if (randomNumber < min) {
                min = randomNumber;
            }
        }

        // 输出结果
        System.out.println("Array: " + Arrays.toString(array));
        System.out.println("Max value: " + max);
        System.out.println("Min value: " + min);
    }
}

这段代码首先初始化数组和两个变量分别记录最大值和最小值，然后在每次循环中生成一个新的随机数，如果这个随机数比当前最大值大，则更新最大值，如果比当前最小值小，则更新最小值。最后，打印出整个数组以及最大值和最小值。