选择排序算法

本文详细介绍了选择排序算法的工作原理,通过不断查找数组中最小值并交换位置来实现排序。提供了一个完整的Java实现,包括随机数组生成、排序算法验证和性能测试。此外,还展示了如何对自定义的`Student`类进行排序,强调了泛型在排序方法中的应用,以及排序算法的时间复杂度分析。

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

所谓的选择排序算法,就是在待排序的数组中不断的去查找最小值的过程;

首先,我们在待排序的数组中查找一个最小值,这个最小值要满足数组中的其他元素都要比它大,将查找到的这个最小值暂存到一个新的数组中;

然后,再查找剩余数组中最小的一个值,不断的重复查询最小值,指定数组中没有值可查为止,将以此查询到的最小值存入到新的数组中,我们就得到了一个有序的数组。

在开发中为了避免空间的浪费,我们不会new一个新数组,而是在原来的数组上实现上述步骤;

实例代码:

准备一个数组生成器:

public class ArrayGenerator {

    private ArrayGenerator(){}

    public static Integer[] generateOrderedArray(int n){
        Integer[] arr = new Integer[n];
        for(int i=0; i < n; i++) {
            arr[i] = i;
        }
            return arr;
    }
    // 生成一个长度为n的随机数组,每个数字的范围是[0,bound)
    public static Integer[] generateEandomArray(int n,int bound){
        Integer[] arr = new Integer[n];
        Random rnd = new Random();
        for(int i=0; i<n; i++){
            arr[i] = rnd.nextInt(bound);
        }
        return arr;
    }
}

排序辅助类

public class SortingHelper {

    private SortingHelper(){}
    //用以验证排序后的数组是否是有序数组
    public static <E extends Comparable> boolean isSorted(E[] arr){
        for(int i = 1;i<arr.length; i++){
            if(arr[i - 1].compareTo(arr[i])>0){
                return false;
            }
        }
        return true;
    }

    //验证算法的时效性
    public static <E extends Comparable> void sortTest(String sortName,E[] arr){
        Long startTime = System.nanoTime();
        if(sortName.equals("SelectionSort")){
            ChoiceTest.genericSort(arr);
        }
        Long endTime = System.nanoTime();
        double time = (endTime - startTime) / 1000000000.0;
        if(!SortingHelper.isSorted(arr)){
            throw new RuntimeException(sortName+" failed!");
        }
        System.out.println(String.format("%s , n = %d : %f s",sortName, arr.length,time));
    }
}

创建一个实体类:

public class Student implements Comparable<Student>{

    private String name;
    private int score;

    public Student(String name, int score){
        this.name = name;
        this.score = score;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name);
    }

    @Override
    public int compareTo(Student another) {
        /*
        if(this.score == another.score)
            return -1;
        else if(this.score == another.score)
            return 0;
        return 1;
        */
        //推荐写法,效果与注释的相同
        return this.score - another.score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

测试类:

/*
* 选择排序
* 选择排序算法是一个不断从数组中找到当中的最小值的过程,首先,在待排序的数组中找到一个最小值,
* 这个最小值要满足一下比数组中其他所有元素都要小,然后再找剩余元素的最小值的,不断的重复查找最小值直到最后一个,
* 这样我们就能得到一个排序好的值。
* */
public class ChoiceTest {

    private ChoiceTest(){}
    //arr[0...i)是有序的;arr{i...n)是无序的——循环不变量
    public static void main(String[] args) {
        /*
        int[] arr = {23,76,12,90,4,2,1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
        */
        int n = 10000;
        //Integer[] arr = {23,76,12,90,4,2,1};
        Integer[] arr = ArrayGenerator.generateEandomArray(n,n);
        Long startTime = System.nanoTime();
        genericSort(arr);
        Long endTime = System.nanoTime();
        double time = (endTime - startTime) / 1000000000.0;

        if(!SortingHelper.isSorted(arr)){
            throw new RuntimeException("SortingHelper failed!");
        }

        System.out.println("Time:"+time);
        //System.out.println(Arrays.toString(arr));

        SortingHelper.sortTest("SelectionSort",arr);
        /*
        Student[] students = {new Student("Alice",98),
                new Student("Bobo",100),
                new Student("Charles",66)};
        ChoiceTest.genericSort(students);
        for(Student student:students){
            System.out.println(student.toString());
        }
        */
    }
    /**
     * 泛型排序方法
     * 让E这种类型实现Comparable接口的,针对泛型语法来说要使用extend来进行约束
     * 在泛型中它表示的不是继承,而是表示实现某一个接口。
     * 实现了这个接口代表的这个类是可比较的
     */
    public static <E extends Comparable<E>> void genericSort(E[] arr){
        for(int i = 0;i < arr.length; i++){
            // 选择 arr[i...n) 中的最小的索引
            int minIndex = i;
            for(int j = i; j < arr.length;j++){
                if(arr[j].compareTo(arr[minIndex]) < 0){
                    minIndex = j;
                }
            }
            genericSwap(arr,i,minIndex);
        }
    }
    //普通排序方法
    public static void sort(int[] arr){
        for(int i = 0;i < arr.length; i++){
            // 选择 arr[i...n) 中的最小的索引
            int minIndex = i;
            for(int j = i; j < arr.length;j++){
                if(arr[j] < arr[minIndex]){
                    minIndex = j;
                }
            }
            swap(arr,i,minIndex);
        }
    }
    //普通方法
    private static void swap(int[] arr, int i, int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
    //泛型方法
    private static <E> void genericSwap(E[] arr, int i, int j){
        E tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

选着排序算法,有两层for循环,假设它的数据体量为n,算法的准确复杂度应该为:(1+n)*n/2,约掉不重要的常数,它的算法复杂度应该为:O(n^{2})。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值