Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 7198533

Browse files
robtaussigtrekhleb
authored andcommitted
Radix sort (trekhleb#28)
* Add in-place sort to QuickSort.js * Fix linting errors and clean up comments * Change implementation to address lint errors * Trailing space and undefined variable * Create own class for in-place quicksort and use tests * Add trailing space at end of file * Fix placement of visitedCallback, explain itial destructuring * Implement Radix Sort Remove excess line Reorganize RadixSort of match structure of other classes Write tests for RadixSort and additional test constants Create README Update main readme to include radix sort
1 parent cca138a commit 7198533

File tree

5 files changed

+150
-0
lines changed

5 files changed

+150
-0
lines changed

‎README.md‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -81,6 +81,7 @@ a set of rules that precisely defines a sequence of operations.
8181
* [Quicksort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/quick-sort) - in-place and non-in-place implementations
8282
* [Shellsort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/shell-sort)
8383
* [Counting Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/counting-sort)
84+
* [Radix Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/radix-sort)
8485
* **Tree**
8586
* [Depth-First Search](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/tree/depth-first-search) (DFS)
8687
* [Breadth-First Search](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/tree/breadth-first-search) (BFS)
@@ -227,3 +228,4 @@ Below is the list of some of the most used Big O notations and their performance
227228
| **Quick sort** | n log(n) | n log(n) | n^2 | log(n) | No | |
228229
| **Shell sort** | n log(n) | depends on gap sequence | n (log(n))^2 | 1 | No | |
229230
| **Counting sort** | n + r | n + r | n + r | n + r | Yes | r - biggest number in array |
231+
| **Radix sort** | n * k | n * k | n * k | n + k | Yes | k - length of longest key |

‎src/algorithms/sorting/SortTester.js‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,8 @@ export const sortedArr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
22
export const reverseArr = [20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
33
export const notSortedArr = [15, 8, 5, 12, 10, 1, 16, 9, 11, 7, 20, 3, 2, 6, 17, 18, 4, 13, 14, 19];
44
export const equalArr = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
5+
export const stringArr = ['zzz', 'bb', 'a', 'rr', 'rrb', 'rrba'];
6+
export const intArr = [3, 1, 75, 32, 884, 523, 4343456, 232, 123, 656, 343];
57

68
export class SortTester {
79
static testSort(SortingClass) {
Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
# Radix Sort
2+
3+
In computer science, 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. Radix sort dates back as far as 1887 to the work of Herman Hollerith on tabulating machines.
4+
5+
## Efficiency
6+
7+
The topic of the efficiency of radix sort compared to other sorting algorithms is somewhat tricky and subject to quite a lot of misunderstandings. Whether radix sort is equally efficient, less efficient or more efficient than the best comparison-based algorithms depends on the details of the assumptions made. Radix sort complexity is O(wn) for n keys which are integers of word size w. Sometimes w is presented as a constant, which would make radix sort better (for sufficiently large n) than the best comparison-based sorting algorithms, which all perform O(n log n) comparisons to sort n keys. However, in general w cannot be considered a constant: if all n keys are distinct, then w has to be at least log n for a random-access machine to be able to store them in memory, which gives at best a time complexity O(n log n).[2] That would seem to make radix sort at most equally efficient as the best comparison-based sorts (and worse if keys are much longer than log n).
8+
9+
The counter argument is that comparison-based algorithms are measured in number of comparisons, not actual time complexity. Under some assumptions the comparisons will be constant time on average, under others they will not. Comparisons of randomly generated keys takes constant time on average, as keys differ on the very first bit in half the cases, and differ on the second bit in half of the remaining half, and so on, resulting in an average of two bits that need to be compared. In a sorting algorithm the first comparisons made satisfies the randomness condition, but as the sort progresses the keys compared are clearly not randomly chosen anymore. For example, consider a bottom-up merge sort. The first pass will compare pairs of random keys, but the last pass will compare keys that are very close in the sorting order. This makes merge sort, on this class of inputs, take O(n (log n)2) time. That assumes all memory accesses cost the same, which is not a physically reasonable assumption as we scale n to infinity, and not, in practice, how real computers work.
10+
11+
## References
12+
13+
- [Wikipedia](https://en.wikipedia.org/wiki/Radix_sort)
Lines changed: 102 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,102 @@
1+
import Sort from '../Sort';
2+
3+
export default class RadixSort extends Sort {
4+
sort(originalArray) {
5+
const isNumber = (element) => {
6+
return Number.isInteger(element);
7+
};
8+
9+
const createBuckets = (numBuckets) => {
10+
/**
11+
* Mapping buckets to an array instead of filling them with
12+
* an array prevents each bucket from containing a reference to the same array
13+
*/
14+
return new Array(numBuckets).fill(null).map(() => []);
15+
};
16+
17+
const placeElementsInNumberBuckets = (array, index) => {
18+
// See below. These are used to determine which digit to use for bucket allocation
19+
const modded = 10 ** (index + 1);
20+
const divided = 10 ** index;
21+
const buckets = createBuckets(10);
22+
23+
array.forEach((element) => {
24+
this.callbacks.visitingCallback(element);
25+
if (element < divided) {
26+
buckets[0].push(element);
27+
} else {
28+
/**
29+
* Say we have element of 1,052 and are currently on index 1 (starting from 0). This means
30+
* we want to use '5' as the bucket. `modded` would be 10 ** (1 + 1), which
31+
* is 100. So we take 1,052 % 100 (52) and divide it by 10 (5.2) and floor it (5).
32+
*/
33+
const currentDigit = Math.floor((element % modded) / divided);
34+
buckets[currentDigit].push(element);
35+
}
36+
});
37+
38+
return buckets;
39+
};
40+
41+
const placeElementsInCharacterBuckets = (array, index, numPasses) => {
42+
const getCharCodeOfElementAtIndex = (element) => {
43+
// Place element in last bucket if not ready to organize
44+
if ((numPasses - index) > element.length) return 25;
45+
// Using charCode (a = 97, b = 98, etc), we can map characters to buckets from 0 - 25
46+
const BASE_CHAR_CODE = 97;
47+
/**
48+
* If each character has been organized, use first character to determine bucket,
49+
* otherwise iterate backwards through element
50+
*/
51+
const charPos = index > element.length - 1 ? 0 : element.length - index - 1;
52+
53+
return element.toLowerCase().charCodeAt(charPos) - BASE_CHAR_CODE;
54+
};
55+
56+
const buckets = createBuckets(26);
57+
58+
array.forEach((element) => {
59+
this.callbacks.visitingCallback(element);
60+
const currentBucket = getCharCodeOfElementAtIndex(element);
61+
buckets[currentBucket].push(element);
62+
});
63+
64+
return buckets;
65+
};
66+
67+
// Assumes all elements of array are of the same type
68+
const isArrayOfNumbers = isNumber(originalArray[0]);
69+
70+
/** Number of passes is determined by the length of the longest element in the array.
71+
* For integers, this log10(num), and for strings, this would be the lenght of the string.
72+
*/
73+
const determineNumPasses = () => {
74+
const getLengthOfLongestElement = () => {
75+
if (isArrayOfNumbers) {
76+
return Math.floor(Math.log10(Math.max(...originalArray))) + 1;
77+
}
78+
79+
return originalArray.reduce((acc, val) => {
80+
return val.length > acc ? val.length : acc;
81+
}, -Infinity);
82+
};
83+
84+
return getLengthOfLongestElement(originalArray);
85+
};
86+
87+
let sortedArray = [...originalArray];
88+
const numPasses = determineNumPasses();
89+
90+
for (let currentIndex = 0; currentIndex < numPasses; currentIndex += 1) {
91+
const buckets = isArrayOfNumbers ?
92+
placeElementsInNumberBuckets(sortedArray, currentIndex) :
93+
placeElementsInCharacterBuckets(sortedArray, currentIndex, numPasses);
94+
// Flatten buckets into sortedArray, and repeat at next index
95+
sortedArray = buckets.reduce((acc, val) => {
96+
return [...acc, ...val];
97+
}, []);
98+
}
99+
100+
return sortedArray;
101+
}
102+
}
Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
import RadixSort from '../RadixSort';
2+
import {
3+
stringArr,
4+
intArr,
5+
SortTester,
6+
} from '../../SortTester';
7+
8+
// Complexity constants.
9+
const ARRAY_OF_STRINGS_VISIT_COUNT = 24;
10+
const ARRAY_OF_INTEGERS_VISIT_COUNT = 77;
11+
describe('RadixSort', () => {
12+
it('should sort array', () => {
13+
SortTester.testSort(RadixSort);
14+
});
15+
16+
it('should visit array of strings n (number of strings) x m (length of longest element) times', () => {
17+
SortTester.testAlgorithmTimeComplexity(
18+
RadixSort,
19+
stringArr,
20+
ARRAY_OF_STRINGS_VISIT_COUNT,
21+
);
22+
});
23+
24+
it('should visit array of integers n (number of elements) x m (length of longest integer) times', () => {
25+
SortTester.testAlgorithmTimeComplexity(
26+
RadixSort,
27+
intArr,
28+
ARRAY_OF_INTEGERS_VISIT_COUNT,
29+
);
30+
});
31+
});

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /