• 算法-线性排序


    package com.test;
    
    /**
     * @Description:桶排序算法
     * @Author: Hoda
     * @Date: Create in 2019-06-01
     * @Modified By:
     * @Modified Date:
     */
    public class BucketSort {
    
        /**
         * 桶排序
         *
         * @param arr 数组
         * @param bucketSize 桶容量
         */
        public static void bucketSort(int[] arr, int bucketSize) {
            if (arr.length < 2) {
                return;
            }
    
            // 数组最小值
            int minValue = arr[0];
            // 数组最大值
            int maxValue = arr[1];
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] < minValue) {
                    minValue = arr[i];
                } else if (arr[i] > maxValue) {
                    maxValue = arr[i];
                }
            }
    
            // 桶数量
            int bucketCount = (maxValue - minValue) / bucketSize + 1;
            int[][] buckets = new int[bucketCount][bucketSize];
            int[] indexArr = new int[bucketCount];
    
            // 将数组中值分配到各个桶里
            for (int i = 0; i < arr.length; i++) {
                int bucketIndex = (arr[i] - minValue) / bucketSize;
                if (indexArr[bucketIndex] == buckets[bucketIndex].length) {
                    ensureCapacity(buckets, bucketIndex);
                }
                buckets[bucketIndex][indexArr[bucketIndex]++] = arr[i];
            }
    
            // 对每个桶进行排序,这里使用了快速排序
            int k = 0;
            for (int i = 0; i < buckets.length; i++) {
                if (indexArr[i] == 0) {
                    continue;
                }
                quickSortC(buckets[i], 0, indexArr[i] - 1);
                for (int j = 0; j < indexArr[i]; j++) {
                    arr[k++] = buckets[i][j];
                }
            }
        }
    
        /**
         * 数组扩容
         *
         * @param buckets
         * @param bucketIndex
         */
        private static void ensureCapacity(int[][] buckets, int bucketIndex) {
            int[] tempArr = buckets[bucketIndex];
            int[] newArr = new int[tempArr.length * 2];
            for (int j = 0; j < tempArr.length; j++) {
                newArr[j] = tempArr[j];
            }
            buckets[bucketIndex] = newArr;
        }
    
        /**
         * 快速排序递归函数
         *
         * @param arr
         * @param p
         * @param r
         */
        private static void quickSortC(int[] arr, int p, int r) {
            if (p >= r) {
                return;
            }
    
            int q = partition(arr, p, r);
            quickSortC(arr, p, q - 1);
            quickSortC(arr, q + 1, r);
        }
    
        /**
         * 分区函数
         *
         * @param arr
         * @param p
         * @param r
         * @return 分区点位置
         */
        private static int partition(int[] arr, int p, int r) {
            int pivot = arr[r];
            int i = p;
            for (int j = p; j < r; j++) {
                if (arr[j] <= pivot) {
                    swap(arr, i, j);
                    i++;
                }
            }
    
            swap(arr, i, r);
            return i;
        }
    
        /**
         * 交换
         *
         * @param arr
         * @param i
         * @param j
         */
        private static void swap(int[] arr, int i, int j) {
            if (i == j) {
                return;
            }
    
            int tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
    }
    package sorts;
    
    /**
     * 计数排序
     *
     * Author: ZHENG
     */
    public class CountingSort {
    
      // 计数排序,a是数组,n是数组大小。假设数组中存储的都是非负整数。
      public static void countingSort(int[] a, int n) {
        if (n <= 1) return;
    
        // 查找数组中数据的范围
        int max = a[0];
        for (int i = 1; i < n; ++i) {
          if (max < a[i]) {
            max = a[i];
          }
        }
    
        // 申请一个计数数组c,下标大小[0,max]
        int[] c = new int[max + 1];
    
        // 计算每个元素的个数,放入c中
        for (int i = 0; i < n; ++i) {
          c[a[i]]++;
        }
    
        // 依次累加
        for (int i = 1; i < max + 1; ++i) {
          c[i] = c[i-1] + c[i];
        }
    
        // 临时数组r,存储排序之后的结果
        int[] r = new int[n];
        // 计算排序的关键步骤了,有点难理解
        for (int i = n - 1; i >= 0; --i) {
          int index = c[a[i]]-1;
          r[index] = a[i];
          c[a[i]]--;
        }
    
        // 将结果拷贝会a数组
        for (int i = 0; i < n; ++i) {
          a[i] = r[i];
        }
      }
    
    }
    /**
     * @Description:基数排序
     * @Author: Hoda
     * @Date: Create in 2019-07-25
     * @Modified By:
     * @Modified Date:
     */
    public class RadixSort {
    
        /**
         * 基数排序
         *
         * @param arr
         */
        public static void radixSort(int[] arr) {
            int max = arr[0];
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
    
            // 从个位开始,对数组arr按"指数"进行排序
            for (int exp = 1; max / exp > 0; exp *= 10) {
                countingSort(arr, exp);
            }
        }
    
        /**
         * 计数排序-对数组按照"某个位数"进行排序
         *
         * @param arr
         * @param exp 指数
         */
        public static void countingSort(int[] arr, int exp) {
            if (arr.length <= 1) {
                return;
            }
    
            // 计算每个元素的个数
            int[] c = new int[10];
            for (int i = 0; i < arr.length; i++) {
                c[(arr[i] / exp) % 10]++;
            }
    
            // 计算排序后的位置
            for (int i = 1; i < c.length; i++) {
                c[i] += c[i - 1];
            }
    
            // 临时数组r,存储排序之后的结果
            int[] r = new int[arr.length];
            for (int i = arr.length - 1; i >= 0; i--) {
                r[c[(arr[i] / exp) % 10] - 1] = arr[i];
                c[(arr[i] / exp) % 10]--;
            }
    
            for (int i = 0; i < arr.length; i++) {
                arr[i] = r[i];
            }
        }
    }
  • 相关阅读:
    使用gdb跟踪Linux内核启动过程(从start_kernel到init进程启动)
    对一个简单的时间片轮转多道程序内核代码的浅析
    初识计算机工作过程
    React 中 路由 react-router-dom 的用法
    Vue Nuxt.js项目启动后可以在局域网内访问的配置方法
    node express async regeneratorRuntime is not defined (已解决)
    node+vue实现微信支付(沙箱)完整版,亲测可用
    node+vue实现支付宝支付(沙箱)完整版,亲测可用
    Vue.js中Line第三方登录api实现[亲测可用]
    React中WebSocket使用以及服务端崩溃重连
  • 原文地址:https://www.cnblogs.com/gendway/p/13823760.html
Copyright © 2020-2023  润新知