选择排序详解-优快云博客

算法原理

1. 数组x，长度为n（n>1），即x[0],x[1], ..., x[n-1]。

2. 第一轮排序，遍历x[0]~x[n-1]，从中找出最小元素x[minIdx]，交换x[0]和x[minIdx]的值。

3. 第二轮排序，遍历x[1]~x[n-1]，从中找出最小元素x[minIdx]，交换x[1]和x[minIdx]的值，以此类推。

4. 经历n-1轮排序后，数组排序完成。

算法实现

package com.cjw.sort;

import java.util.Arrays;
import java.util.Random;

/**
 * 使用选择排序对整型数组进行排序
 *
 * Created by cjw on 2017/8/20 0020.
 */
public class SelectionSortUtil {

    /**
     * 选择排序算法实现
     *
     * @param x 待排序的数组
     */
    public static void sort(int[] x) {
        if (x == null || x.length < 2) {
            return;
        }
        int len = x.length;
        int minIdx;
        for (int time = 1; time < len; time++) {
            minIdx = time - 1; //暂时认为x[time-1]的元素为最小值
            //查找索引范围[time, n-1]中最小的元素
            for (int i = time; i < len; i++) {
                if (x[i] < x[minIdx]) {
                    minIdx = i;
                }
            }
            //交换
            swap(x, time-1, minIdx);
            debugPrint(time, x);
        }
    }

    /**
     * 交换数组x索引位置为a和b的值
     *
     * @param x 数组
     * @param a 索引a
     * @param b 索引b
     */
    private static void swap(int[] x, int a, int b) {
        int temp = x[a];
        x[a] = x[b];
        x[b] = temp;
    }

    /**
     * 调试输出排序过程中数组中的数据
     *
     * @param time  排序次数
     * @param x     数组
     */
    private static void debugPrint(int time, int[] x) {
        System.out.println("第" + time + "次排序结果：" + Arrays.toString(x));
    }

    public static void main(String[] args) {
        int[] x = { 87, 12, 39, 34, 134, 4, 45, 8, 99, 1 };
        sort(x);
    }
}

程序输出：

第1次排序结果：[1, 12, 34, 39, 134, 4, 45, 8, 99, 87]
第2次排序结果：[1, 4, 34, 39, 134, 12, 45, 8, 99, 87]
第3次排序结果：[1, 4, 8, 39, 134, 12, 45, 34, 99, 87]
第4次排序结果：[1, 4, 8, 12, 134, 39, 45, 34, 99, 87]
第5次排序结果：[1, 4, 8, 12, 34, 39, 45, 134, 99, 87]
第6次排序结果：[1, 4, 8, 12, 34, 39, 45, 134, 99, 87]
第7次排序结果：[1, 4, 8, 12, 34, 39, 45, 134, 99, 87]
第8次排序结果：[1, 4, 8, 12, 34, 39, 45, 87, 99, 134]
第9次排序结果：[1, 4, 8, 12, 34, 39, 45, 87, 99, 134]

Process finished with exit code 0

我们发现，上述的选择排序，是每次找出最小元素，其实每次遍历时，可以把最小元素和最大元素一并找出来，然后分别放在左右两侧，这样内层、外层遍历的层数就会少很多。

程序改进：

/**
 * 改进后的选择排序算法(每次都找出最大值和最小值）
 *
 * @param x 待排序的数组
 */
public static void optimizedSort(int[] x) {
    if (x == null || x.length < 2) {
        return;
    }
    int len = x.length;
    //两头都进行选择，外层排序次数减少一半
    int totalTimes = len % 2 == 0 ? len / 2 : len /2 + 1;
    int minIdx, maxIdx;
    for (int time = 1; time <= totalTimes; time++) {
        minIdx = time - 1;
        maxIdx = len  - time;
        for (int i = time; i <= len-time; i++) {
            if (x[i] < x[minIdx]) {
                minIdx = i;
            }
            if (x[i] > x[maxIdx]) {
                maxIdx = i;
            }
        }
        swap(x, time-1, minIdx);
        swap(x, len-time, maxIdx);
        debugPrint(time, x);
    }
}

public static void main(String[] args) {
    int[] x = { 87, 12, 39, 34, 134, 4, 45, 8, 99, 1 };
    optimizedSort(x);
}

测试结果：

第1次排序结果：[1, 12, 39, 34, 87, 4, 45, 8, 99, 134]
第2次排序结果：[1, 4, 39, 34, 87, 12, 45, 8, 99, 134]
第3次排序结果：[1, 4, 8, 34, 39, 12, 45, 87, 99, 134]
第4次排序结果：[1, 4, 8, 12, 39, 34, 45, 87, 99, 134]
第5次排序结果：[1, 4, 8, 12, 34, 39, 45, 87, 99, 134]

转载于:https://my.oschina.net/vbird/blog/1517695