zoukankan      html  css  js  c++  java
  • 算法-线性排序

    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];
            }
        }
    }
  • 相关阅读:
    JavaScript cookie详解
    Javascript数组的排序:sort()方法和reverse()方法
    javascript中write( ) 和 writeln( )的区别
    div做表格
    JS 盒模型 scrollLeft, scrollWidth, clientWidth, offsetWidth 详解
    Job for phpfpm.service failed because the control process exited with error code. See "systemctl status phpfpm.service" and "journalctl xe" for details.
    orm查询存在价格为空问题
    利用救援模式破解系统密码
    SSH服务拒绝了密码
    C# 调用 C++ DLL 中的委托,引发“对XXX::Invoke类型的已垃圾回收委托进行了回调”错误的解决办法
  • 原文地址:https://www.cnblogs.com/gendway/p/13823760.html
Copyright © 2011-2022 走看看