排序： 选择排序

1. 基本原理

将待排序的元素分为已排序(初始为空)和未排序两组，依次将未排序的元素中值最小的元素放入已排序的组中。

直接选择排序简单直观，但性能略差；堆排序是一种较高效的选择排序方法，但实现起来略微复杂。

2. 直接选择排序

基本过程为：

• 在一组元素R[i]到R[n]中选择具有最小关键码的元素
• 若它不是这组元素中的第一个元素，则将它与这组元素中的第一个元素对调。
• 除去具有最小关键字的元素，在剩下的元素中重复第(1)、(2)步，直到剩余元素只有一个为止。

3. 代码实现

package com.windy.sort;

import java.util.Arrays;

import org.junit.Test;

public class SelectSort {

    class DataWrap implements Comparable<DataWrap> {
        int data;
        String flag;

        public DataWrap(int data, String flag) {
            this.data = data;
            this.flag = flag;
        }

        @Override
        public String toString() {
            return data + flag;
        }

        @Override
        public int compareTo(DataWrap dw) {

            return this.data > dw.data ? 1 : (this.data == dw.data ? 0 : -1);

        }
    }

    @Test
    public void test1() {

        DataWrap[] dw = new DataWrap[] { 
                new DataWrap(-9, ""), 
                new DataWrap(1, ""),
                new DataWrap(-47, "*"),
                new DataWrap(1246, ""), 
                new DataWrap(758, ""), 
                new DataWrap(-123, ""), 
                new DataWrap(5, ""),
                new DataWrap(638, ""), 
                new DataWrap(-47, ""), 
                new DataWrap(5, "*")
                };

        System.out.println("排序前：
" + Arrays.toString(dw));
        selectSort(dw);
        System.out.println("排序后：
" + Arrays.toString(dw));
    }

    @Test
    public void test2() {
        DataWrap[] dw = new DataWrap[] { 
                new DataWrap(-9, ""), 
                new DataWrap(1, ""),
                new DataWrap(-47, "*"),
                new DataWrap(1246, ""), 
                new DataWrap(758, ""), 
                new DataWrap(-123, ""), 
                new DataWrap(5, ""),
                new DataWrap(638, ""), 
                new DataWrap(-47, ""), 
                new DataWrap(5, "*")
                };

        System.out.println("排序前：
" + Arrays.toString(dw));
        selectSort2(dw);
        System.out.println("排序后：
" + Arrays.toString(dw));
    }

    // 直接选择排序
    private static void selectSort(DataWrap[] dw) {

        int length = dw.length;

        System.out.println("排序中...");

        for (int i = 0; i < length - 1; i++) {

            for (int j = i + 1; j < length; j++) {
                if (dw[i].compareTo(dw[j]) > 0) {
                    DataWrap temp;
                    temp = dw[i];
                    dw[i] = dw[j];
                    dw[j] = temp;
                }
            }

            System.out.println(Arrays.toString(dw));
        }

    }

    /*
     * 直接选择排序改进版 用临时变量记录最小值的下标，而不是选择马上交换 在对比一轮结束之后，才选择交换
     */
    private static void selectSort2(DataWrap[] dw) {
        int length = dw.length;

        System.out.println("排序中...");
        for (int i = 0; i < length - 1; i++) {
            int min = i;

            for (int j = i + 1; j < length; j++) {
                // 用最小值去对比，而不是dw[i]
                if (dw[min].compareTo(dw[j]) > 0) {
                    min = j;
                }
            }

            DataWrap temp;
            temp = dw[i];
            dw[i] = dw[min];
            dw[min] = temp;

            System.out.println(Arrays.toString(dw));
        }

    }

}

结果打印：

排序前：
[-9, 1, -47*, 1246, 758, -123, 5, 638, -47, 5*]
排序中...
[-123, 1, -9, 1246, 758, -47*, 5, 638, -47, 5*]
[-123, -47*, 1, 1246, 758, -9, 5, 638, -47, 5*]
[-123, -47*, -47, 1246, 758, 1, 5, 638, -9, 5*]
[-123, -47*, -47, -9, 1246, 758, 5, 638, 1, 5*]
[-123, -47*, -47, -9, 1, 1246, 758, 638, 5, 5*]
[-123, -47*, -47, -9, 1, 5, 1246, 758, 638, 5*]
[-123, -47*, -47, -9, 1, 5, 5*, 1246, 758, 638]
[-123, -47*, -47, -9, 1, 5, 5*, 638, 1246, 758]
[-123, -47*, -47, -9, 1, 5, 5*, 638, 758, 1246]
排序后：
[-123, -47*, -47, -9, 1, 5, 5*, 638, 758, 1246]

4. 算法效率分析

• 算法的时间效率：无论初始状态如何，在第i趟排序中选择最小关键码的元素，需做n-i次比较，因此总的比较次数为：

        

• 算法的空间效率：空间效率很高，只需要一个附加程序单元用于交换，其空间效率为O(1)

• 算法的稳定性：不稳定