数组练习_Java代码_算法_冒泡排序法_枚举

1.冒泡排序BubbleSort.java：
（1）定义一个包含1000个元素的一维数组，数组的元素类型是int。
（2）使用顺序的数填充该数组，使用冒泡排序算法对数组元素进行排序，并估算排序的时间。
（3）使用逆序的数填充该数组，使用冒泡排序算法对数组元素进行排序，并估算排序的时间。
（4）使用Math类随机生成1000个数填充该数组，使用冒泡排序算法对数组元素进行排序，并估算排序的时间。
（5）试对比上述时间的运行差异，并说明为什么? 把数组元素类型改成double，并观察排序的时间。

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

/**
 * 1.冒泡排序BubbleSort.java：
 * （1）定义一个包含1000个元素的一维数组，数组的元素类型是int。
 * （2）使用顺序的数填充该数组，使用冒泡排序算法对数组元素进行排序，并估算排序的时间。
 * （3）使用逆序的数填充该数组，使用冒泡排序算法对数组元素进行排序，并估算排序的时间。
 * （4）使用Math类随机生成1000个数填充该数组，使用冒泡排序算法对数组元素进行排序，并估算排序的时间。
 * （5）试对比上述时间的运行差异，并说明为什么? 把数组元素类型改成double，并观察排序的时间。
 */
public class BubbleSort {
    public static void main(String[] args) {
        //自动生成一个数组
        //int[] arr = new int[1000];
        //Random random = new Random();
        //for (int i = 0; i < arr.length; i++) {
        //    arr[i] = random.nextInt(20000);
        //}
        //System.out.println(Arrays.toString(arr));

        //使用Math类生成一个数组
        int [] arr2 = new int[1000];
        for (int i = 0; i < arr2.length; i++) {
            arr2[i] = (int) (Math.random()*(20000-1)+1);
        }
        System.out.println(Arrays.toString(arr2));
        //静态定义一个数组
        //int[] arr2 = {12，13};//此处如果静态初始化，会比较麻烦。所以选择自动生成一个随机数组。

        //顺序冒泡法排序并计时
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < arr2.length - 1; i++) {
            for (int j = 0; j < arr2.length - 1 - i; j++) {
                int min = arr2[j];
                if (arr2[j] > arr2[j + 1]) {
                    arr2[j] = arr2[j + 1];
                    arr2[j + 1] = min;
                }
            }
        }
        System.out.println(Arrays.toString(arr2));
        long endTime = System.currentTimeMillis();
        System.out.println("顺序排的时间是：" + (endTime - startTime));

        //顺序冒泡法排序并计时
        long startTime2 = System.currentTimeMillis();
        for (int i = 0; i < arr2.length - 1; i++) {
            for (int j = 0; j < arr2.length - 1 - i; j++) {
                int max = arr2[j];
                if (arr2[j] < arr2[j + 1]) {
                    arr2[j] = arr2[j + 1];
                    arr2[j + 1] = max;
                }
            }
        }
        System.out.println(Arrays.toString(arr2));
        long endTime2 = System.currentTimeMillis();
        System.out.println("逆序排的时间是：" + (endTime2 - startTime2));
    }
}

2.在OI、ICPC和CCPC等程序设计竞赛中，常使用以下几种代码来表示对所提交程序的判定结果:

AC
Accepted
通过

WA
Wrong Answer
答案错误

TLE
Time Limit Exceed
超时

OLE
Output Limit Exceed
超过输出限制

MLE
Memory Limit Exceed
超内存

RE
Runtime Error
运行时错误

PE
Presentation Error
格式错误

CE
Compile Error
无法编译

请使用枚举编写简易程序判定器：

定义枚举类型Result，其中包含上述AC、WA等所有常量，并编写构造方法标注各常量对应的中文含义和英文含义。
随机生成一个整数（1~8，分别表示上述8种情形），并输出该整数对应的枚举常量及其中英文含义。

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入判断代号：1,2,3,4,5,6,7,8");
        int inputInt = scanner.nextInt();

        switch (inputInt){
            case 1:
                System.out.println(Result.AC.getChinese());
                System.out.println(Result.AC.getEnglish());
                break;
            case 2:
                System.out.println(Result.WA.getChinese());
                System.out.println(Result.WA.getEnglish());
                break;
            case 3:
                System.out.println(Result.TLE.getChinese());
                System.out.println(Result.TLE.getEnglish());
                break;
            case 4:
                System.out.println(Result.OLE.getChinese());
                System.out.println(Result.OLE.getEnglish());
                break;
            case 5:
                System.out.println(Result.MLE.getChinese());
                System.out.println(Result.MLE.getEnglish());
                break;
            case 6:
                System.out.println(Result.RE.getChinese());
                System.out.println(Result.RE.getEnglish());
                break;
            case 7:
                System.out.println(Result.PE.getChinese());
                System.out.println(Result.PE.getEnglish());
                break;
            case 8:
                System.out.println(Result.CE.getChinese());
                System.out.println(Result.CE.getEnglish());
                break;
        }
    }
}

enum Result{
    AC("Accepted","通过"),WA("Wrong Answer","答案错误"),
    TLE("Time Limit Exceed","超时"),OLE("Output Limit Exceed","超过输出限制"),
    MLE("Memory Limit Exceed","超内存"),RE("Runtime Error","运行时错误"),
    PE("Presentation Error","格式错误"),CE("Compile Error","无法编译");

    private String English;
    private String Chinese;

    Result(String english, String chinese) {
        English = english;
        Chinese = chinese;
    }

    public String getEnglish() {
        return English;
    }

    public void setEnglish(String english) {
        English = english;
    }

    public String getChinese() {
        return Chinese;
    }

    public void setChinese(String chinese) {
        Chinese = chinese;
    }
}