源源的学习笔记之JAVA_DAY_05

于 2023-08-10 09:11:56 发布
阅读量95 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： 学习 笔记 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62848520/article/details/132180499
本文详细介绍了Java中的快速排序算法，包括其思想、具体步骤以及递归实现。同时，对比了冒泡排序、选择排序和插入排序。并通过实例演示了如何在平均成绩数组中查找特定成绩的排名。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

排序

快速排序法

思想：在循环开始的时候，选择一个值作为中间值，通过一次循环，将要排序的数据分成独立的左右两部分，左边的值比中间小，右边的值比中间大，按照这个方法重复递归，直到排序完成

具体步骤：

1.选择第一个数据作为中间值

2.声明两个变量，分别作为数组的第一个下标i和最后一个下标j

3.通过下标依次和中间值做比较，如果i的下标对应值比中间值大，等待j的下标对应值比中间值小的值，然后i和j对应的值进行交换（循环这一步，直至i和j重合的位置）

4.重合位置之后，j继续向左走一格，和中间值进行交换

上述的一轮操作，称为一趟排序

递归调用上面的方法，最终实现排序

package quicksort;

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) {
            while (temp <= arr[j] && i < j) {
                j--;
            }
            while (temp >= arr[i] && i < j) {
                i++;
            }
            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[] = {1,5,3,7,3,9};
        printArray(arr);
        quickSort(arr,0, arr.length -1);
        printArray(arr);

    }
}

运行结果：

测试排序时间

package shijianceshi;

import java.util.Random;

public class shijanceshi {
    //冒泡排序
    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;
                }
            }
        }
    }
    //快速排序
    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) {
            while (temp <= arr[j] && i < j) {
                j--;
            }
            while (temp >= arr[i] && i < j) {
                i++;
            }
            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 selectSort(int[] arr){
        //存在一个有序区和无序区
        //排序开始之前，有序区没有内容
        //第一次排序的时候，将第一个数值标记为有序的第一个值
        for (int i = 0; i < arr.length - 1; i++) {
            //指定一个最小数值的索引
            int minIndex = i;
            //从有序区的后面的第一个(i+1)开始遍历
            for (int j = i+1; j < arr.length ; j++) {
                //找到最小的值
                if (arr[j] < arr[minIndex]){
                    //将最小值的下标做交换
                    minIndex = j;
                }
            }
            //循环之后，做数据交换
            if (i != minIndex){
                int temp = arr[i] ;
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }
    public static void insertSort(int[] arr){
        //第一次循环从第二个元素开始，默认第一个元素是有序的
        for (int i = 1; i < arr.length; i++) {
            //指定一个插入数
            int insertNum = arr[i];

            //指定一个已经排序好的元素的个数
            int j = i - 1;
            //循环判断
            //如果插入的值，小于前面的有序区的最后一个值(arr[j])，
            //把有序区的最后一个值往后移动，
            //然后再和最后一个值前面的值（arr[j-1]）作比较，所以，
            //循环的时候，需要做j-- 操作
            while ( j >= 0 && arr[j] > insertNum){
                arr[j+1] = arr[j];
                j--;
            }
            arr[j+1] = insertNum;
        }
    }
        public static void main(String[] args) {
            Random random = new Random();
            int[] arr = new int[1000000];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = random.nextInt(100000);
            }
            //System.currentTimeMillis()可以放回当前时间的毫秒值
            long start = System.currentTimeMillis();
            //调用排序方法
            bubbleSort(arr);
            //insertSort(arr);
            //quickSort(arr,0,arr.length-1);
            //selectSort(arr);

            long end = System.currentTimeMillis();
            long time = end - start;
            System.out.println("排序时间:" + time);
        }

    }

 查找算法

查找：指在指定数组中，查找指定的值，返回其下标

二分法

定义最小索引和最大索引，并以此找到中间索引，用查找的值和中间索引对应值进行比较，如果相等，直接返回这个值，如果比中间值大，就往右找，如果比中间值小，就往左找，并重新计算中间索引，最大最小索引均需改变，重复上面的操作

package erfen;

import java.util.Scanner;

public class erfen {
    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之间随机生成

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

package chengji;

import java.util.Random;

public class chengji {
    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;
    }
    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;
                }
            }
        }
    }
    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) {
        Random random = new Random();
        int arr[] = new int[10];
        arr[0]=84;
        for (int i = 1; i <= 9; i++) {
            arr[i] = random.nextInt(30)+70;
        }
       bubbleSort(arr);
        System.out.println("成绩排序为：");
       printArray(arr);
       int c = getIndex(arr,84);
        System.out.println("小明排第"+(c+1)+"名");
    }
}

Arrays工具类


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));
    }
}

眰恦46
关注
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值