正常的选择排序

选择排序是每一次从待排序的数据元素中选出最小的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

　　分为三步：

　　①、从待排序序列中，找到关键字最小的元素

　　②、如果最小元素不是待排序序列的第一个元素，将其和第一个元素互换

　　③、从余下的 N - 1 个元素中，找出关键字最小的元素，重复(1)、(2)步，直到排序结束

代码如下

 1 package com.ssm.排序算法;
 2
 3 public class 选择排序 {
 4     /**
 5      * 换位方法
 6      */
 7     public static void swap(int[] array, int x, int y) {
 8         int temp;
 9         temp = array[x];
10         array[x] = array[y];
11         array[y] = temp;
12     }
13
14     /**
15      * 排序方法
16      */
17     public static int[] sort(int[] array) {
18         for (int i = 0; i < array.length-1; i++) {
19                 int min = i;
20             for (int j = i+1; j < array.length; j++) {
21                   min = array[min]>array[j]? j:min;
22             }
23               if(min!=i){
24                   swap(array,min,i);
25               }
26         }
27         return array;
28     }
29
30     /**
31      * 遍历方法
32      *
33      * @param array
34      */
35     public static void display(int[] array) {
36         for (int i = 0; i < array.length; i++) {
37             System.out.print(array[i] + " ");
38         }
39         System.out.println();
40     }
41
42     public static void main(String[] args) {
43         int[] array = {4, 2, 8, 9, 5, 7, 6, 1, 3};
44         System.out.println("排序前的数组是：");
45         display(array);
46         System.out.println("---------------------------");
47         System.out.println("排序后的数组是：");
48         display(sort(array));
49     }
50 }

优化后的选择排序

这里优化的思路就是在每次循环找出最小值的时候同时找出最大值并排序，这样的话循环的次数就会少一半

核心代码如下

 1    /**
 2      * 排序方法
 3      */
 4     public static int[] sort(int[] array) {
 5
 6         //这样优化之后选择排序需要循环的次数直接缩减了一半
 7         for (int i = 0; i < (array.length/2); i++) {
 8             int maxLength = array.length - (i + 1);
 9             int min = i;
10             int max = maxLength;
11
12             for (int j = i + 1; j < array.length - i; j++) {
13                 min = array[min] > array[j] ? j : min;
14                 //每次循环都找出最大值和最小值
15                 max = array[max] < array[j] ? j : max;
16             }
17
18             if (min != i) {
19                 swap(array, min, i);
20             }
21
22             if (max != maxLength) {
23                 swap(array, max, maxLength);
24             }
25         }
26         return array;
27     }

验证选择排序的稳定性

原文地址：https://www.cnblogs.com/xiaowangtongxue/p/10703773.html