import java.util.Scanner; public class SortArray { public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.println("请输入数组长度："); int n = input.nextInt(); int[] arr = new int[n]; for (int i = 0; i < n; i++) { System.out.printf("请输入第 %d 个数：", i+1); arr[i] = input.nextInt(); } sort(arr); // 调用排序方法 System.out.println("排序后的数组为："); for (int i = 0; i < n; i++) { System.out.println(arr[i] + " "); } System.out.println("\n倒置后的数组为："); for (int i = n-1; i >= 0; i--) { System.out.println(arr[i] + " "); } } public static void sort(int[] arr) { // 冒泡排序算法 int n = arr.length; for (int i = 0; i < n-1; i++) { for (int j = 0; j < n-i-1; j++) { if (arr[j] > arr[j+1]) { int tmp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = tmp; } } } } }

这是一个Java程序，实现了一个冒泡排序算法，可以对输入的整数数组进行排序，并输出排序结果和倒置后的数组。程序首先通过Scanner读取用户输入的数组长度和数组元素，然后调用sort方法进行排序，最后输出排序结果和倒置后的数组。

sort方法实现了冒泡排序算法，通过两层循环遍历整个数组，每次比较相邻两个元素的大小，如果前面的元素比后面的元素大，则交换它们的位置。这样重复遍历整个数组，直到所有元素都按照从小到大的顺序排列。

在程序中，sort方法是一个静态方法，可以直接通过类名调用。程序中的主方法main通过调用sort方法实现了对数组的排序。程序还实现了倒置输出数组的功能，通过遍历数组并倒序输出数组元素实现。

总体来说，这是一个简单易懂的Java程序，适合初学者学习和练习。

相关问题

根据代码绘制出类图 import java.io.File; import java.io.FileNotFoundException; import java.io.PrintWriter; import java.util.Scanner; import java.util.Arrays; public class Test{ public static void main(String[] args) throws FileNotFoundException { File file = new File("Exercise12_15.txt"); if(file.exists()) { System.out.println("File already exists"); } try(PrintWriter output = new PrintWriter(file)){ String s=""; for(int i = 0; i < 100; i++){ s+=(int)(Math.random()*100)+" "; } output.print(s); } try (Scanner input = new Scanner(file)){ String[] string = new String[100]; int[] array = new int[100]; for(int i = 0; i < 100; i++) { string[i] = input.next(); System.out.print(string[i]); System.out.print(" "); } System.out.println(); for(int i = 0; i < 100; i++) { array[i] = Integer.parseInt(string[i]); } Arrays.sort(array); for(int i = 0; i < 100; i++) { System.out.print(array[i]); System.out.print(" "); } } } } }

类名：Test

属性：
- 无

方法：
+ main(args: String[]) : void
- writeToFile(file: File) : void
- readFromFile(file: File) : void

关系：
- File

其中，符号解释如下：
- 类名：表示类的名称，一般使用大写字母开头的驼峰式命名法。
- 属性：表示类的成员变量，可以包括数据类型、名称等信息。
- 方法：表示类的成员函数，可以包括参数、返回值、名称等信息。
- +：表示public权限，-：表示private权限。
- :：表示返回值类型，void表示无返回值。
- args: String[]：表示方法的参数类型和名称，String[]表示字符串数组类型。

根据上述解释，可以绘制出以下类图：

       +------------------------+
       |          Test          |
       +------------------------+
       |                        |
       +------------------------+
       | + main(args: String[]) |
       |- writeToFile(file: File)|
       |- readFromFile(file: File)|
       +------------------------+
                 |
                 V
                File

下面java代码转化为c import java.util.*; public class Main{ public static void main(String args[]) { Scanner scan = new Scanner(System.in); String line; while (scan.hasNextLine()) { line = scan.nextLine().trim(); // please write your code here String[] strs=line.split("\\s+"); int[]ints=new int[strs.length]; for(int i=0;i<strs.length;i++) { ints[i]=Integer.valueOf(strs[i]); } try { int[]ints1=sort(ints); for(int i=0;i<ints1.length;i++) { System.out.print(ints1[i]+" "); } } catch (Exception e) { e.printStackTrace(); } System.out.println(); } } static int[] sort(int[] sourceArray) throws Exception { int[] arr = Arrays.copyOf(sourceArray, sourceArray.length); int maxDigit = getMaxDigit(arr); return radixSort(arr, maxDigit); } static int getMaxDigit(int[] arr) { int maxValue = getMaxValue(arr); return getNumLenght(maxValue); } static int getNumLenght(long num) { if (num == 0) { return 1; } int lenght = 0; for (long temp = num; temp != 0; temp /= 10) { lenght++; } return lenght; } static int getMaxValue(int[] arr) { int maxValue = arr[0]; for (int value : arr) { if (maxValue < value) { maxValue = value; } } return maxValue; } static int[] radixSort(int[] arr, int maxDigit) { int mod = 10; int dev = 1; for (int i = 0; i < maxDigit; i++, dev *= 10,mod *= 10) { int[][] counter = new int[20][0]; for (int j = 0; j < arr.length; j++) { int bucket = ((arr[j] % mod) / dev)+10; counter[bucket] = arrayAppend(counter[bucket], arr[j]); } int pos = 0; for (int[] bucket : counter) { for (int value : bucket) { arr[pos++] = value; } } } return arr; } static int[] arrayAppend(int[] arr, int value) { arr = Arrays.copyOf(arr, arr.length + 1); arr[arr.length - 1] = value; return arr; } }

下面是将Java代码转换为C的等效代码：

c
#include <stdio.h>
#include <stdlib.h>

int* arrayAppend(int* arr, int value, int length) {
arr = (int*)realloc(arr, (length + 1) * sizeof(int));
arr[length] = value;
return arr;
}

int getMaxValue(int* arr, int length) {
int maxValue = arr[0];
for (int i = 1; i < length; i++) {
if (maxValue < arr[i]) {
maxValue = arr[i];
}
}
return maxValue;
}

int getNumLength(long num) {
if (num == 0) {
return 1;
}
int length = 0;
for (long temp = num; temp != 0; temp /= 10) {
length++;
}
return length;
}

int getMaxDigit(int* arr, int length) {
int maxValue = getMaxValue(arr, length);
return getNumLength(maxValue);
}

int* radixSort(int* arr, int length, int maxDigit) {
int mod = 10;
int dev = 1;
for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
int** counter = (int**)malloc(20 * sizeof(int*));
for (int j = 0; j < 20; j++) {
counter[j] = (int*)malloc(0 * sizeof(int));
}
for (int j = 0; j < length; j++) {
int bucket = ((arr[j] % mod) / dev) + 10;
counter[bucket] = arrayAppend(counter[bucket], arr[j], sizeof(counter[bucket]) / sizeof(counter[bucket][0]));
}
int pos = 0;
for (int j = 0; j < 20; j++) {
for (int k = 0; k < sizeof(counter[j]) / sizeof(counter[j][0]); k++) {
arr[pos++] = counter[j][k];
}
free(counter[j]);
}
free(counter);
}
return arr;
}

int* sort(int* sourceArray, int length) {
int* arr = (int*)malloc(length * sizeof(int));
for (int i = 0; i < length; i++) {
arr[i] = sourceArray[i];
}
int maxDigit = getMaxDigit(arr, length);
return radixSort(arr, length, maxDigit);
}

int main() {
char line[100];
while (fgets(line, sizeof(line), stdin)) {
int ints[100];
int intsLength = 0;
char* token = strtok(line, " ");
while (token != NULL) {
ints[intsLength++] = atoi(token);
token = strtok(NULL, " ");
}
int* sortedInts = sort(ints, intsLength);
for (int i = 0; i < intsLength; i++) {
printf("%d ", sortedInts[i]);
}
printf("\n");
free(sortedInts);
}
return 0;
}

需要注意的是，C语言中没有内置的动态数组，因此我们需要使用`realloc`和`malloc`来动态分配和重新分配内存。另外，在C语言中，我们需要手动释放动态分配的内存，以避免内存泄漏。在这个C代码中，我们使用了`malloc`和`realloc`来分配和重新分配内存，并使用`free`来释放内存。

此外，为了与Java代码中的`Scanner`相对应，我们使用了`fgets`来从标准输入读取整行输入，并使用`strtok`来将输入字符串分割成整数数组。最后，我们通过循环打印排序后的整数数组，并在每行结束后释放内存。

请注意，上述代码是根据Java代码逐行转换得来的，可能不是最优的C实现。为了提高性能和效率，你可以进一步优化该代码。