radix-sort

Below is an LSD Radix sort implementation in Java from a textbook to sort an array of strings where each string contains exactly W characters. I want to count the number of array accesses during runtime. I've read that LSD sort is supposed to require n * c array accesses where n is the number of strings and c the amount of characters in each string. However, the algorithm below accesses more than one array several times. If I increment a counter at each of these I'll end up with a significant factor of nc . So what exactly constitutes 'array access' in the context of algorithms? Is there only

I've wanted to create a radix sort implementation using queues. I couldn't figure out which part of my code has problems or which resources should I read. My code may be totally wrong but this is my implementation without any help (I haven't taken a data structures & algorithms course yet). I created a function but it didn't work. While doing research, I saw some code samples but they seemed to be more complex for me. Firstly I wanted to find the least significant digit of all integers Then sort them in queue element whose subscript matches, then after sort copy all queues to end of 11th queue

Algorithms like Timsort, Quicksort & Mergesort dominate the " real world " sorting methods. The case for these comparison sorts is quite practical — they've been shown to be the most performant, stable, multipurpose sorting algorithms in a wide variety of environments. However, it seems like nearly everything that we would sort on a computer are countable / partially ordered. Numbers, characters, strings, even functions are amenable to some meaningful non-comparison sorting method. A candidate here is Radix sort. In general it will behave faster than O(n*log(n)), beating the theoretical

The book "Introduction to Algorithms" mentions about the LSD (Least Significant Digit) version of radix sort. However , as others have pointed out here in stackoverflow, a MSD (Most Significant Digit) version also exists. So I want to know the pros and cons of each of these. My guess is that the LSD version has some benefits over the MSD one but I am not sure. Hence the question. Taken from the link, might be useful: http://www.eternallyconfuzzled.com/tuts/algorithms/jsw_tut_sorting.aspx (At the very bottom) The biggest problem with LSD radix sort is that it starts at the digits that make the

I have a datastructure with a field of the float-type. A collection of these structures needs to be sorted by the value of the float. Is there a radix-sort implementation for this. If there isn't, is there a fast way to access the exponent, the sign and the mantissa. Because if you sort the floats first on mantissa, exponent, and on exponent the last time. You sort floats in O(n). Philip Daubmeier Update: I was quite interested in this topic, so I sat down and implemented it (using this very fast and memory conservative implementation ). I also read this one (thanks celion ) and found out that

It seems Radix sort has a very good average case performance, i.e. O(kN) : http://en.wikipedia.org/wiki/Radix_sort but it seems most people still are using Quick Sort, don't they? Quick sort has an average of O(N logN), but it also has a worst case of O(N^2), so even due in most practical cases it wont get to N^2, there is always the risk that the input will be in "bad order" for you. This risk doesn't exist in radix sort. I think this gives a great advantage to radix sort. Radix sort is harder to generalize than most other sorting algorithms. It requires fixed size keys, and some standard way