选择排序

选择排序原理:

　　从待排序的元素中选出最小(大)的元素放在起始位置,然后再从剩余的元素中选出最小(大)的元素放在已排好的部分之后,直到只剩最后一个待排序的元素为止.

示例:

　　例如数组[47,38,96,72,88,24],按照升序进行排序,排序过程如下:

　　第一轮:

　　　　47>38,交换位置,数组变为[38,47,96,72,88,24];

　　　　38<96,不交换位置;

　　　　38<72,不交换位置;

　　　　38<88,不交换位置;

　　　　38>24,交换位置,数组变为[24,47,96,72,88,38];

　　　　第一轮之后,最小的元素到达初始位置,数组变为[24,47,96,72,88,38].

　　第二轮:

　　　　47<96,不交换位置;

　　　　47<72,不交换位置;

　　　　47<88,不交换位置;

　　　　47>38,交换位置,数组变成[24,38,96,72,88,47];

　　　　第二轮之后,剩余元素的最小者到达已排序部分之后,数组变成[24,38,96,72,88,47].

　　第三轮:

　　　　96>72,交换位置,数组变成[24,38,72,96,88,47];

　　　　72<88,不交换位置;

　　　　72>47,交换位置,数组变成[24,38,47,96,88,72];

　　　　第三轮之后,剩余元素的最小者到达已排序部分之后,数组变成[24,38,47,96,88,72].

　　第四轮:

　　　　96>88,交换位置,数组变成[24,38,47,88,96,72];

　　　　88>72,交换位置,数组变成[24,38,47,72,96,88];

　　　　第四轮之后,剩余元素的最小者到达已排序部分之后,数组变成[24,38,47,72,96,88].

　　第五轮:

　　　　96>88,交换位置,数组变成[24,38,47,72,88,96];

　　　　第五轮之后,剩余元素的最小者到达已排序部分之后,数组变成[24,38,47,72,88,96].

　　至此,数组元素排序就完成了,排序后的数组变成[24,38,47,72,88,96].

结论:

　　由上面的排序过程可以看出,6个元素只需要(元素数-1)轮排序,每轮排序只进行(元素数-轮数)次比较.

java代码实现:

　　

package com.yg.study;

public class SelectionSort {

    public static void main(String[] args) {
        int[] arr= {47,38,96,72,88,24};
        doSort(arr);
        System.out.println("===============排序后的数组为==============");        //可以删除
        for (int i : arr) {
            System.out.print(i+"\t");
        }
    }

    private static void doSort(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {        //-1是用于不确定轮数
            System.out.println("*****************第"+(i+1)+"轮排序*****************");        //用于确定轮数,可以删除
            for(int j=i+1;j<arr.length;j++) {        //j=i+1用于去除元素和自己的比较
                if(arr[i]>arr[j]) {
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
                for (int k : arr) {        //用于查看每一次比较后的数组变化,可以删除
                    System.out.print(k+"\t");
                }
                System.out.println();        //用于区别每一次比较后的数组元素,可以删除
            }
        }
        
    }

}

结果展示: