所谓的选择排序算法,就是在待排序的数组中不断的去查找最小值的过程;
首先,我们在待排序的数组中查找一个最小值,这个最小值要满足数组中的其他元素都要比它大,将查找到的这个最小值暂存到一个新的数组中;
然后,再查找剩余数组中最小的一个值,不断的重复查询最小值,指定数组中没有值可查为止,将以此查询到的最小值存入到新的数组中,我们就得到了一个有序的数组。
在开发中为了避免空间的浪费,我们不会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()。