一、選擇排序

        選擇排序（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 +
                '}';
    }
}