操作系统---实验2---进程与线程---2022.10

参考资料：
Java生成不重复的随机数组的方法（这里用的是方法3）
冒泡排序

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

public class ThreeSort {
    public static void main(String[] args) {
        //生成一个不重复的随机数组
        int[] a = get_arr();

        BubbleSort bubbleSort = new BubbleSort(a);
        SelectSort selectSort = new SelectSort(a);
        QuickSort quickSort = new QuickSort(a);

        new Thread(bubbleSort, "冒泡排序").start();
        new Thread(selectSort, "选择排序").start();
        new Thread(quickSort, "快速排序").start();
    }

    public static int[] get_arr() {
        int[] a = new int[1000];
        RandomArr randomArr = new RandomArr(a);
        return a;
    }
}

class RandomArr {
    int a[];

    //生成一个不重复的随机数组
    public RandomArr(int[] a) {
        int min = 1, max = 1000;
        int len = max - min + 1;

        //初始化给定范围的待选数组
        int[] source = new int[len];
        for (int i = min; i < min + len; i++) {
            source[i - min] = i;
        }

        Random rd = new Random();
        int index = 0;
        for (int i = 0; i < 1000; i++) {
            //待选数组0到(len-2)随机一个下标
            index = Math.abs(rd.nextInt() % len--);
            //将随机到的数放入结果集
            a[i] = source[index];
            //将待选数组中被随机到的数，用待选数组(len-1)下标对应的数替换
            source[index] = source[len];
        }
        this.a = a;
    }
}

class BubbleSort implements Runnable {
    private int[] a;

    public BubbleSort(int[] a) {
        this.a = a;
    }

    @Override
    public void run() {
        //生成一个不重复的随机数组
        //int[] a = get_arr();
        System.out.println("冒泡--原数组：" + Arrays.toString(a));
        bubble_sort(a);
        System.out.println("冒泡--排序后：" + Arrays.toString(a));
    }

    public static int[] get_arr() {
        int[] a = new int[1000];
        RandomArr randomArr = new RandomArr(a);
        return a;
    }

    public static void bubble_sort(int[] a) {
        for (int i = 0; i < a.length - 1; i++) {
            // 比较相邻两个元素，较大的数往后冒泡
            for (int j = 0; j < a.length - 1 - i; j++) {
                if (a[j] > a[j + 1]) {
                    int temp = a[j + 1]; // 把第一个元素值保存到临时变量中
                    a[j + 1] = a[j]; // 把第二个元素值转移到第一个元素变量中
                    a[j] = temp; // 把临时变量（第一个元素的原值）保存到第二个元素中
                }
            }
        }
    }
}

class SelectSort implements Runnable {
    private int[] a;

    public SelectSort(int[] a) {
        this.a = a;
    }

    @Override
    public void run() {
        //生成一个不重复的随机数组
        //int[] a = get_arr();
        System.out.println("选择--原数组：" + Arrays.toString(a));
        select_sort(a);
        System.out.println("选择--排序后：" + Arrays.toString(a));
    }

    public static int[] get_arr() {
        int[] a = new int[1000];
        RandomArr randomArr = new RandomArr(a);
        return a;
    }

    public static void select_sort(int[] a) {
        for (int i = 0; i < a.length - 1; i++) {
            int minIndex = i; // 用来记录最小值的索引位置，默认值为i
            for (int j = i + 1; j < a.length; j++) {
                if (a[j] < a[minIndex]) {
                    minIndex = j; // 遍历 i+1~length 的值，找到其中最小值的位置
                }
            }
            // 交换当前索引 i 和最小值索引 minIndex 两处的值
            if (i != minIndex) {
                int temp = a[i];
                a[i] = a[minIndex];
                a[minIndex] = temp;
            }
            // 执行完一次循环，当前索引 i 处的值为最小值，直到循环结束即可完成排序
        }
    }
}

class QuickSort implements Runnable {
    private int[] a;

    public QuickSort(int[] a) {
        this.a = a;
    }

    @Override
    public void run() {
        //生成一个不重复的随机数组
        //int[] a = get_arr();
        System.out.println("快排--原数组：" + Arrays.toString(a));
        quick_sort(a, 0, a.length - 1);
        System.out.println("快排--排序后：" + Arrays.toString(a));
    }

    public static int[] get_arr() {
        int[] a = new int[1000];
        RandomArr randomArr = new RandomArr(a);
        return a;
    }

    public static void quick_sort(int[] q, int l, int r) {
        if (l >= r) return;
        int x = q[l + r >> 1], i = l - 1, j = r + 1;
        while (i < j) {
            while (q[++i] < x) ;
            while (q[--j] > x) ;
            if (i < j) {
                int t = q[i];
                q[i] = q[j];
                q[j] = t;
            }
        }
        quick_sort(q, l, j);
        quick_sort(q, j + 1, r);
    }
}