一、选择排序（Selection sort）

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u014155085/article/details/80237413

一、选择排序

        选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完，选择排序是不稳定的排序方法。

示例代码：

/**
 * 选择排序
 */
public class SelectionSort {

    public static void main(String[] args) {

        //生成数组
       int array[]={9,8,7,6,5,4,3,2,1,0};

        //打印生成的数组
        System.out.print("生成的数组：");
        printArray(array);

        //打印排序后的数组
        System.out.print("排序的数组：");
        printArray(SelectionSort(array));
    }

    /**
     * 选择排序
     * @param array
     * @return
     */
    public static int[] SelectionSort(int [] array){
        for (int i=0;i<array.length;i++){
            //求数组下标范围[i,array.length-1]内的最小值
            int minIndex = getArrayMinIndex(array,i,array.length-1);
            //数组下标值互换
            indexSwap(array,i,minIndex);
        }
        return array;
    }

    /**
     * 在数组下标范围[startIndex,endIndex]内，求最小值的下标
     * @param array 数组
     * @param startIndex 数组的开始下标
     * @param endIndex 数组的结束下标
     * @return
     */
    public static int getArrayMinIndex(int [] array,int startIndex,int endIndex){
        int minIndex=startIndex;
        for (int i=startIndex+1;i<=endIndex;i++){
            if (array[i]<array[minIndex]){
                minIndex=i;
            }
        }
        return minIndex;
    }

    /**
     * 打印数组
     * @param array
     */
    public static void printArray(int[] array){
        for (int num:array){
            System.out.print(num+"\t");
        }
        System.out.println();
    }

    /**
     * 数组下标值互换
     * @param array 目标数组
     * @param indexA 下标 A
     * @param indexB 下标 B
     */
    public static void indexSwap(int [] array,int indexA,int indexB){
        int temp=array[indexA];
        array[indexA]=array[indexB];
        array[indexB]=temp;
    }
}

延伸拓展：

    支持int，double，String，Student类的排序。

/**
 * 选择排序
 */
public class SelectionSort {


    public static void main(String[] args) {

        /** 测试int */
        //生成数组
        Comparable[] intArray = {9,8,7,6,5,4,3,2,1};
        //打印生成的数组
        System.out.print("生成的int数组：");
        printArray(intArray);
        //打印排序后的数组
        System.out.print("排序的int数组：");
        printArray(SelectionSort(intArray));

        /** 测试double */
        //生成数组
        Comparable[] doubleArray = {9.01,8.98,7.62,6.2,5.5,4.3,3.9,2.1,1.1,1.5};
        //打印生成的数组
        System.out.print("生成的double数组：");
        printArray(doubleArray);
        //打印排序后的数组
        System.out.print("排序的double数组：");
        printArray(SelectionSort(doubleArray));

        /** 测试 String */
        //生成数组
        Comparable[] stringArray = {"A123","B321","A124","张三","李四","123","124"};
        //打印生成的数组
        System.out.print("生成的String数组：");
        printArray(stringArray);
        //打印排序后的数组
        System.out.print("排序的String数组：");
        printArray(SelectionSort(stringArray));

        /** 测试Student */
        //生成数组
        Student student1=new Student("B",90);
        Student student2=new Student("A",90);
        Student student3=new Student("C",70);
        Student student4=new Student("D",60);
        Comparable[] StudentArray={student1,student2,student3,student4};
        //打印生成的数组
        System.out.print("生成的Student数组：");
        printArray(StudentArray);
        //打印排序后的数组
        System.out.print("排序的Student数组：");
        printArray(SelectionSort(StudentArray));


    }


    /**
     * 选择排序
     *
     * @param array
     * @return
     */
    public static Comparable[] SelectionSort(Comparable[] array) {
        for (int i = 0; i < array.length; i++) {
            //求数组下标范围[i,array.length-1]内的最小值下标
            int minIndex = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[j].compareTo(array[minIndex]) == -1) {
                    minIndex = j;
                }
            }
            //数组下标值互换
            indexSwap(array, i, minIndex);
        }
        return array;
    }

    /**
     * 打印数组
     *
     * @param array
     */
    public static void printArray(Comparable[] array) {
        for (Object num : array) {
            System.out.print(num.toString() + ",\t");
        }
        System.out.println();
    }

    /**
     * 数组下标值互换
     *
     * @param array  目标数组
     * @param indexA 下标 A
     * @param indexB 下标 B
     */
    public static void indexSwap(Comparable[] array, int indexA, int indexB) {
        Comparable temp = array[indexA];
        array[indexA] = array[indexB];
        array[indexB] = temp;
    }
}

student类：通过实现Comparable接口，重写compareTo方法，来实现类之间的比较。

/**
 * @作者：***
 * @创建时间：2018/5/9 9:46
 */
public class Student implements Comparable<Student> {

    private String name;
    private int score;

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


    /**
     * 比较分数大小
     * 如果分数相等则比较名字
     * @param student
     * @return
     */
    @Override
    public int compareTo(Student student) {
        if (this.score>student.score)
            return 1;
        else if(this.score<student.score)
            return -1;
        else{
            return this.name.compareTo(student.name);
        }
    }

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