• Java RadixSort


    Java RadixSort

    /**
     * <html>
     * <body>
     *  <P> Copyright 1994-2018 JasonInternational </p>
     *  <p> All rights reserved.</p>
     *  <p> Created on 2018年4月10日 </p>
     *  <p> Created by Jason</p>
     *  </body>
     * </html>
     */
    package cn.ucaner.algorithm.sorts;
    
    import java.util.Arrays;
    
    /**
     * Radix sort is a non-comparative integer sorting algorithm that sorts data
     * with integer keys by grouping keys by the individual digits which share the
     * same significant position and value. A positional notation is required, but
     * because integers can represent strings of characters (e.g., names or dates)
     * and specially formatted floating point numbers, radix sort is not limited to
     * integers. 
     * <p>
     * Family: Bucket.<br>
     * Space: 10 Buckets with at most n integers per bucket.<br> 
     * Stable: True.<br>
     * <p>
     * Average case = O(n*k)<br>
     * Worst case = O(n*k)<br>
     * Best case = O(n*k)<br>
     * <p> 
     * NOTE: n is the number of digits and k is the average bucket size
     * <p>
     * @see <a href="https://en.wikipedia.org/wiki/Radix_sort">Radix Sort (Wikipedia)</a>
     * <br>
     * @author Justin Wetherell <phishman3579@gmail.com>
     */
    public class RadixSort {
    
        private static final int NUMBER_OF_BUCKETS = 10; // 10 for base 10 numbers
    
        private RadixSort() { }
    
        public static Integer[] sort(Integer[] unsorted) {
            int[][] buckets = new int[NUMBER_OF_BUCKETS][10];
            for (int i = 0; i < NUMBER_OF_BUCKETS; i++)
                buckets[i][0] = 1; // Size is one since the size is stored in first element
            int numberOfDigits = getMaxNumberOfDigits(unsorted); // Max number of digits
            int divisor = 1;
            for (int n = 0; n < numberOfDigits; n++) {
                int digit = 0;
                for (int d : unsorted) {
                    digit = getDigit(d, divisor);
                    buckets[digit] = add(d, buckets[digit]);
                }
                int index = 0;
                for (int i = 0; i < NUMBER_OF_BUCKETS; i++) {
                    int[] bucket = buckets[i];
                    int size = bucket[0];
                    for (int j = 1; j < size; j++) {
                        unsorted[index++] = bucket[j];
                    }
                    buckets[i][0] = 1; // reset the size
                }
                divisor *= 10;
            }
            return unsorted;
        }
    
        private static int getMaxNumberOfDigits(Integer[] unsorted) {
            int max = Integer.MIN_VALUE;
            int temp = 0;
            for (int i : unsorted) {
                temp = (int) Math.log10(i) + 1;
                if (temp > max)
                    max = temp;
            }
            return max;
        }
    
        private static int getDigit(int integer, int divisor) {
            return (integer / divisor) % 10;
        }
    
        private static int[] add(int integer, int[] bucket) {
            int size = bucket[0]; // size is stored in first element
            int length = bucket.length;
            int[] result = bucket;
            if (size >= length) {
                result = Arrays.copyOf(result, ((length * 3) / 2) + 1);
            }
            result[size] = integer;
            result[0] = ++size;
            return result;
        }
    }
    

      

  • 相关阅读:
    数组小练习
    数组
    利用数组进行排序
    继承练习
    黄金分割点
    百万富翁-循环练习
    SelectedIndexChanged事件, SelectedValueChanged事件和SelectionChangeCommitted事件的区别及应用——c#
    进制转换以及与字符串之间转换——c#
    文件中的类都不能进行设计,因此未能为该文件显示设计器
    winfrom自绘窗体边框——c#
  • 原文地址:https://www.cnblogs.com/jasonandy/p/9243179.html
Copyright © 2020-2023  润新知