数据结构与算法-直接选择排序

package *;

import java.math.BigDecimal;
import java.util.Date;

/**
 * @program: data-structure
 * @description: 直接选择排序
 * @author: ChenWenLong
 * @create: 2019-09-10 14:14
 **/
public class SelectSort {

    /**
     * 功能描述:
     * 〈由于交换位置放在了第一层循环里面，所以速度会比冒泡（放在了第二层循环中）快〉
     *
     * @params : [array]
     * @return : void
     * @author : cwl
     * @date : 2019/9/10 14:15
     */
    public void selectSort(int[] array){
        //作为最大值（或最小）的下标
        int index;
        for(int i=1;i<array.length;i++){
            //默认第一个最大（或最小）
            index=0;
            for(int j=1;j<array.length-i;j++){
                //取最大值的下标
                if(array[j]>array[index]){
                    index=j;
                }
            }
            //在上面的for循环中找到了最大（最小）值的下标
            //交换位置
            //一次循环都会将一个最值放到最后，所以长度逐次递减
            int temp=array[array.length-i];
            array[array.length-i]=array[index];
            array[index]=temp;
        }
    }

    /**
     * 功能描述: double
     * 〈〉
     *
     * @params : [array]
     * @return : void
     * @author : cwl
     * @date : 2019/9/10 14:17
     */
    public void selectSort(double[] array){
        //作为最大值（或最小）的下标
        int index;
        for(int i=1;i<array.length;i++){
            //默认第一个最大（或最小）
            index=0;
            for(int j=1;j<array.length-i;j++){
                //取最大值的下标
                if(array[j]>array[index]){
                    index=j;
                }
            }
            //在上面的for循环中找到了最大（最小）值的下标
            //交换位置
            //一次循环都会将一个最值放到最后，所以长度逐次递减
            double temp=array[array.length-i];
            array[array.length-i]=array[index];
            array[index]=temp;
        }
    }

    /**
     * 功能描述:
     * 〈〉
     *
     * @params : [array]
     * @return : void
     * @author : cwl
     * @date : 2019/9/10 14:17
     */
    public void selectSort(long[] array){
        //作为最大值（或最小）的下标
        int index;
        for(int i=1;i<array.length;i++){
            //默认第一个最大（或最小）
            index=0;
            for(int j=1;j<array.length-i;j++){
                //取最大值的下标
                if(array[j]>array[index]){
                    index=j;
                }
            }
            //在上面的for循环中找到了最大（最小）值的下标
            //交换位置
            //一次循环都会将一个最值放到最后，所以长度逐次递减
            long temp=array[array.length-i];
            array[array.length-i]=array[index];
            array[index]=temp;
        }
    }

    /**
     * 功能描述: char
     * 〈〉
     *
     * @params : [array]
     * @return : void
     * @author : cwl
     * @date : 2019/9/10 14:17
     */
    public void selectSort(char[] array){
        //作为最大值（或最小）的下标
        int index;
        for(int i=1;i<array.length;i++){
            //默认第一个最大（或最小）
            index=0;
            for(int j=1;j<array.length-i;j++){
                //取最大值的下标
                if(array[j]>array[index]){
                    index=j;
                }
            }
            //在上面的for循环中找到了最大（最小）值的下标
            //交换位置
            //一次循环都会将一个最值放到最后，所以长度逐次递减
            char temp=array[array.length-i];
            array[array.length-i]=array[index];
            array[index]=temp;
        }
    }

    /**
     * 功能描述: String 根据长度排序
     * 〈〉
     *
     * @params : [array]
     * @return : void
     * @author : cwl
     * @date : 2019/9/10 14:17
     */
    public void selectSort(String[] array){
        //作为最大值（或最小）的下标
        int index;
        for(int i=1;i<array.length;i++){
            //默认第一个最大（或最小）
            index=0;
            for(int j=1;j<array.length-i;j++){
                //取最大值的下标
                if(array[j].length()>array[index].length()){
                    index=j;
                }
            }
            //在上面的for循环中找到了最大（最小）值的下标
            //交换位置
            //一次循环都会将一个最值放到最后，所以长度逐次递减
            String temp=array[array.length-i];
            array[array.length-i]=array[index];
            array[index]=temp;
        }
    }

    /**
     * 功能描述:BigDecimal
     * 〈〉
     *
     * @params : [array]
     * @return : void
     * @author : cwl
     * @date : 2019/9/10 14:20
     */
    public void selectSort(BigDecimal[] array){
        //作为最大值（或最小）的下标
        int index;
        for(int i=1;i<array.length;i++){
            //默认第一个最大（或最小）
            index=0;
            for(int j=1;j<array.length-i;j++){
                //取最大值的下标
                if(array[j].compareTo(array[index]) == 1){
                    index=j;
                }
            }
            //在上面的for循环中找到了最大（最小）值的下标
            //交换位置
            //一次循环都会将一个最值放到最后，所以长度逐次递减
            BigDecimal temp=array[array.length-i];
            array[array.length-i]=array[index];
            array[index]=temp;
        }
    }

    /**
     * 功能描述: Date
     * 〈〉
     *
     * @params : [array]
     * @return : void
     * @author : cwl
     * @date : 2019/9/10 14:20
     */
    public void selectSort(Date[] array){
        //作为最大值（或最小）的下标
        int index;
        for(int i=1;i<array.length;i++){
            //默认第一个最大（或最小）
            index=0;
            for(int j=1;j<array.length-i;j++){
                //取最大值的下标
                if(array[j].compareTo(array[index]) == 1){
                    index=j;
                }
            }
            //在上面的for循环中找到了最大（最小）值的下标
            //交换位置
            //一次循环都会将一个最值放到最后，所以长度逐次递减
            Date temp=array[array.length-i];
            array[array.length-i]=array[index];
            array[index]=temp;
        }
    }

}