zoukankan      html  css  js  c++  java
  • java 整型数组基本排序,冒泡,快速选择,插入,归并

    在学java泛型,于是把排序拿来练练手了

    import java.util.Arrays;
    
    public class GenericArraySort {
        public static void main(String[] args){
    
            Integer[] integers = getGenericArray(2,41,12,3);
            bubbleSort(integers);
            System.out.println("integer:");
            System.out.println(Arrays.toString(integers));
    
            Long[] longs = getGenericArray(123L, 22L,12L, 3L);
            selectSort(longs);
            System.out.println("long:");
            System.out.println(Arrays.toString(longs));
    
            Float[] floats = getGenericArray(3.2f,2.4f,1.5f, 22.2f);
            insertSort(floats);
            System.out.println("float:");
            System.out.println(Arrays.toString(floats));
    
            Double[] doubles = getGenericArray(5.2,2.4,1.5,22.2);
            mergeSort(doubles);
            System.out.println("double:");
            System.out.println(Arrays.toString(doubles));
        }
    
        /**
         * 比较2个数字的大小
         * @param a
         * @param b
         * @return
         */
        public static boolean compareNumberVal(Number a, Number b){
            boolean ret = false;
    
            if(a instanceof Integer){
                if(a.intValue() > b.intValue()){
                    ret = true;
                }
            }else if(a instanceof Long){
                if(a.longValue() > b.longValue()){
                    ret = true;
                }
            }else if(a instanceof Float){
                if(a.floatValue() > b.floatValue()){
                    ret = true;
                }
            }else if(a instanceof Double){
                if(a.doubleValue() > b.doubleValue()){
                    ret = true;
                }
            }else if(a instanceof Byte){
                if(a.byteValue() > b.byteValue()){
                    ret = true;
                }
            }else if(a instanceof Short){
                if(a.shortValue() > b.shortValue()){
                    ret = true;
                }
            }
            return ret;
        }
    
        /**
         * 交换整型数组 i 和 j 的value
         * @param i
         * @param j
         * @param param
         * @param <T>
         */
        public static <T extends Number> void exchangeKey(int i, int j, T param[]){
            T tmp = param[i];
            param[i] = param[j];
            param[j] = tmp;
        }
    
        /**
         * 冒泡排序
         * @param param
         * @param <T>
         */
        public static <T extends Number> void  bubbleSort(T param[]){
            int len = param.length;
            for(int i = 1; i < len ; i++){
                for(int j = len - 1; j >= i; j--){
                    //一一对比, 逐个替换
                    if(compareNumberVal(param[j - 1], param[j])){
                        exchangeKey(j - 1, j, param);
                    }
                }
            }
        }
    
        /**
         * 快速选择排序
         * @param param
         * @param <T>
         */
        public static <T extends Number> void  selectSort(T param[]){
            int len = param.length;
            for(int i = 0; i < len ; i++){
                T min = param[i];
                int minIndex = i;
                int oi = i;
                for(int j = len - 1; j >= i; j--){
                    //一一对比, 取得最小的key 再替换
                    if(compareNumberVal(min, param[j])){
                        min = param[j];
                        minIndex = j;
                    }
                }
                if(minIndex != oi){
                    exchangeKey(i, minIndex, param);
                }
            }
        }
    
        /**
         * 插入排序
         * @param param
         * @param <T>
         */
        public static <T extends Number> void  insertSort(T param[]){
            int len = param.length;
            for(int i = 1; i < len ; i++){
                int j = i;
                T tmp = param[j]; //存临时变量
    
                //逐个向后比较 假如大于 则往后移
                while(j > 0 && compareNumberVal(param[j - 1], tmp)){
                    param[j] = param[j - 1];
                    j--;
                }
                param[j] = tmp;
            }
        }
    
        public static <T extends Number> void mergeSort(T param[]){
            mergeProcess(param, 0, param.length - 1);
        }
    
        /**
         * 递归处理归并排序
         * @param param
         * @param l
         * @param r
         * @param <T>
         */
        public static <T extends Number> void mergeProcess(T param[], int l, int r){
    
            if(l >= r){
                return;
            }
            int mid = (l + r) / 2;  //中间位置 把数组切分为2段
            mergeProcess(param, l , mid );
            mergeProcess(param, mid + 1 , r );
            merge(param, l , r);
        }
        /**
         * 合并排序好的数组段
         * @param param
         * @param l
         * @param r
         * @param <T>
         */
        public static <T extends Number> void  merge(T param[], int l, int r){
    
            int mid = (l + r) / 2;  //中间位置 把数组切分为2段
            int rs = mid + 1;  //右侧数组起始key   左 0 - mid  右 rs - r
            int cs = l;  //临时排序数组的起始key(和原数组 l相同)
            int s = l;  //备份原数组起始key
            Number[] tmpArr = new Number[param.length];  //临时排序数组
    
            //重新排序  2个数组取最前面key 比较大小 放到 临时数组
            while(l <= mid && rs <= r){
                if(compareNumberVal(param[l], param[rs])){
                    tmpArr[cs++] = param[rs++];
                }else{
                    tmpArr[cs++] = param[l++];
                }
            }
    
            //左侧 剩余部分 拷贝 临时数组
            while (l <= mid){
                tmpArr[cs++] = param[l++];
            }
    
            //右侧 剩余部分拷贝临时数组
            while (rs <= r){
                tmpArr[cs++] = param[rs++];
            }
    
            //临时排序好的数组重新拷贝回 param
            while(s <= r){
                param[s] = (T)tmpArr[s++];
            }
        }
        /**
         * 通过参数获取泛型数组
         * @param arg
         * @param <T>
         * @return
         */
        public static <T> T[] getGenericArray(T ... arg){
            return arg;
        }
    
        /**
         * 打印泛型数组
         * @param a
         * @param <T>
         */
        public static <T> void showArr(T a[]){
            int len = a.length;
            for (int i = 0; i < len; i++){
                System.out.println(a[i]);
            }
        }
    }
    

      

    作者:做想其成
    本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须在文章页面给出原文链接,否则保留追究法律责任的权利。
  • 相关阅读:
    字符串 CSV解析 表格 逗号分隔值 通讯录 电话簿 MD
    Context Application 使用总结 MD
    RxJava RxPermissions 动态权限 简介 原理 案例 MD
    Luban 鲁班 图片压缩 MD
    FileProvider N 7.0 升级 安装APK 选择文件 拍照 临时权限 MD
    组件化 得到 DDComponent JIMU 模块 插件 MD
    gradlew 命令行 build 调试 构建错误 Manifest merger failed MD
    protobuf Protocol Buffers 简介 案例 MD
    ORM数据库框架 SQLite 常用数据库框架比较 MD
    [工具配置]requirejs 多页面,多入口js文件打包总结
  • 原文地址:https://www.cnblogs.com/zxqc/p/7485156.html
Copyright © 2011-2022 走看看