Java4(2)

快速排序

public class QuickSort {

    //写一个快速排序的方法
    public static void quickSort(int[] arr,int left , int right){
        //提前声明需要使用的变量
        int  i,j,temp,t;
        //递归结束条件
        if (left > right){
            return;
        }
        //开始排序
        i = left;
        j = right;
        temp = arr[left]; //中间值
        //循环判断
        while (i < j){
            //如果j下标的值，比中间值大，j做--操作
            while (temp <= arr[j] && i < j){
                j--;
            }
            //如果i下标的值，比中间值小，i做++操作
            while (temp >= arr[i] && i < j){
                i++;
            }
            //如果上面两个条件不满足，i 和 j 交换
            if(i < j){
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }
        }
        //最后需要将中间值和 j的值做交换
        arr[left] = arr[j];
        arr[j] = temp;
        //递归调用左边
        quickSort(arr,left,j-1);
        //递归调用右边
        quickSort(arr,j+1,right);
    }
    //输出方法
    public static void printArray(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        int[] arr = {10,31,43,2,34,12,4};
        System.out.println("排序前");
        printArray(arr);
        //调用排序方法
        quickSort(arr,0,arr.length-1);
        System.out.println("排序后");
        printArray(arr);
    }
}

测试排序时间

/*
测试排序时间
 */
public class SortTime {
    public static void main(String[] args) {
        //循环往数组中，存放1万条随机数据

        //使用Random类，可以生成随机数
        Random random = new Random();
        //int i = random.nextInt(100000);//生成随机数
        //System.out.println(i);
        //声明一个长度为10000的数组
        int[] arr = new int[10000];
        for (int i = 0; i < arr.length; i++) {
            //往数组中存入100000以内的数据
            arr[i] = random.nextInt(100000);
        }
        //System.currentTimeMillis()可以放回当前时间的毫秒值
        long start = System.currentTimeMillis();
        System.out.println("排序前:");
        //调用排序方法
        //BubbleSort.bubbleSort(arr);
        //InsertSort.insertSort(arr);
        //QuickSort.quickSort(arr,0,arr.length-1);
        //SelectSort.selectSort(arr);
        System.out.println("排序后:");
        long end = System.currentTimeMillis();
        long time = end - start;
        System.out.println("排序时间:" + time);
    }
}

查找算法

即返回数组下标：

public class SearchDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {12,34,56,23,11,66,39,36};

        //查找39在数组中的什么位置？返回它的下标
        //基本查找方式:
        int index = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == 39){
                index = i;
                break;
            }
        }
        System.out.println("查找的39的下标:" + index);
    }
}

二分查找

/*
二分查找
 */
public class BinarySearch {
    public static void main(String[] args) {
        //定义一个有序的数组
        int[] arr = {11,22,33,44,55,66,77,88,99};

        int index = getIndex(arr, 44);
        System.out.println("44的下标是:" + index);
    }
    //写一个二分查找方法,返回值是 索引值
    //参数是 数组和 要查找的值
    public static int getIndex(int[] arr,int value){
        //定义最小索引、最大索引
        int max = arr.length -1 ;
        int min = 0;
        //计算中间索引
        int mid = (max + min) / 2;
        //拿查找的值和中间索引值做比较
        //如果中间值和查找的值不同，就循环，相同，循环结束
        while (value != arr[mid]){
            //中间值大 ，往左找
            if (arr[mid] > value){
                max = mid - 1;
                //中间值小,往右找
            }else if (arr[mid] < value){
                min = mid + 1;
            }
            //判断,没有找到的情况
            if (min > max){
                return -1;
            }
            mid = (max + min) / 2;
        }
        return mid;
    }
}

例题：

数组中，存放了10位同学的平均成绩，其中张三的成绩是84分，其他人的平均成绩在70-100之间随机生成

求：生成成绩后，张三的成绩在班级中的排名是多少

public class Demo01 {
    public static void main(String[] args) {
        /*
        数组中，存放了10位同学的平均成绩，其中张三的成绩是84分，
        其他人的平均成绩在70-100之间随机生成
        求：生成成绩后，张三的成绩在班级中的排名是多少
         */

        //随机生成数组数据
        int[] arr = new int[10];
        arr[0] = 84;
        //创建随机数对象random
        Random random = new Random();
        for (int i = 1; i < arr.length; i++) {
            arr[i] = random.nextInt(30) + 70;
        }
        System.out.println("所有学生的平均成绩:");
        BubbleSort.printArray(arr);
        //数组排序
        BubbleSort.bubbleSort(arr);
        //数组查找
        int index = BinarySearch.getIndex(arr, 84);
        int paiming = arr.length - index;
        System.out.println("张三的排名是:" + paiming);
    }
}

Arrays工具类

jdk提供给我们使用的一个工具类，工具类中一般都封装了 很多的方法，可以给我们使用

public class ArraysDemo {
    public static void main(String[] args) {
        int[] arr = {10,33,4,21,35,6};
        //toString()方法， 将数组以字符串形式输出
        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr); //调用排序方法
        System.out.println(Arrays.toString(arr));

        int i = Arrays.binarySearch(arr, 33); //搜索
        System.out.println(i);
            //复制数组
        int[] arr01 = Arrays.copyOf(arr, 10);
        System.out.println(Arrays.toString(arr01));

        char[] charArray = {'a','c','b','x','f'};
        Arrays.sort(charArray);
        System.out.println(Arrays.toString(charArray));
    }
}

Arrays 是 Java 中的一个工具类，它包含了许多用于操作数组的静态方法1。例如，您可以使用 Arrays.sort 方法对数组进行排序，使用 Arrays.binarySearch 方法在数组中搜索指定的值，使用 Arrays.copyOf 和 Arrays.copyOfRange 方法复制数组，使用 Arrays.equals 和 Arrays.deepEquals 方法比较两个数组是否相等，等等。

由于 Arrays 类中的方法都是静态方法，因此您可以直接通过类名调用这些方法，而不需要创建 Arrays 类的对象。例如，您可以使用 Arrays.sort(myArray) 来对名为 myArray 的数组进行排序。