radix_sort2.cpp File Reference

Algorithm of Radix sort More...

`#include <algorithm>`
`#include <cassert>`
`#include <iostream>`
`#include <vector>`
Include dependency graph for radix_sort2.cpp:

## Namespaces

| sorting
| Sorting algorithms.
| radix_sort
| Functions for Radix sort algorithm.

## Functions

std::vector< uint64_t > | sorting::radix_sort::step_ith (uint16_t cur_digit, const std::vector< uint64_t > &ar)
| Function to sort vector according to current digit using stable sorting. More...
std::vector< uint64_t > | sorting::radix_sort::radix (const std::vector< uint64_t > &ar)
| Function to sort vector digit by digit. More...
static void | tests ()
| Function to test the above algorithm. More...
int | main ()
| Main function. More...

## Detailed Description

Algorithm of Radix sort

Author
  Suyash Jaiswal

Sort the vector of unsigned integers using radix sort i.e. sorting digit by digit using Counting Sort as subroutine. Running time of radix sort is O(d*(n+b)) where b is the base for representing numbers and d in the max digits in input integers and n is number of unsigned integers. consider example for n = 5, aray elements = 432,234,143,332,123 sorting digit by digit sorting according to 1) 1st digit place => 432, 332, 143, 123, 234

2) 2nd digit place => 123, 432, 332, 234, 143

3) 3rd digit place => 123, 143, 234, 332, 432

using count sort at each step, which is stable. stable => already sorted according to previous digits.

## Function Documentation

## main()

int main | ( | void |  | ) |

Main function.

Returns
  0 on exit

{
tests(); // execute the tests
return 0;
}
tests
static void tests()
Function to test the above algorithm.
Definition: radix_sort2.cpp:102
Here is the call graph for this function:

## radix()

std::vector<uint64_t> sorting::radix_sort::radix | ( | const std::vector< uint64_t > & | ar | ) |

Function to sort vector digit by digit.

Parameters

  ar | - vector to be sorted

Returns
  sorted vector

{
uint64_t max_ele =
*max_element(ar.begin(), ar.end()); // returns the max element.
std::vector<uint64_t> temp = ar;
for (int i = 1; max_ele / i > 0;
i *= 10) { // loop breaks when i > max_ele because no further digits
// left to makes changes in aray.
temp = step_ith(i, temp);
}
for (uint64_t i : temp) {
std::cout << i << " ";
}
std::cout << "\n";
return temp;
}
std::cout
std::vector::begin
T begin(T... args)
std::vector::end
T end(T... args)
std::max_element
T max_element(T... args)
sorting::radix_sort::step_ith
std::vector< uint64_t > step_ith(uint16_t cur_digit, const std::vector< uint64_t > &ar)
Function to sort vector according to current digit using stable sorting.
Definition: radix_sort2.cpp:49
std::vector< uint64_t >
Here is the call graph for this function:

## step_ith()

std::vector<uint64_t> sorting::radix_sort::step_ith | ( | uint16_t | cur_digit,
|  | const std::vector< uint64_t > & | ar
| ) |  |

Function to sort vector according to current digit using stable sorting.

Parameters

  cur_digit | - sort according to the cur_digit
  ar | - vector to be sorted

Returns
  std::vector sorted till ith digit

{ // sorting according to current digit.
int n = ar.size();
std::vector<uint32_t> position(10, 0);
for (int i = 0; i < n; ++i) {
position[(ar[i] / cur_digit) %
10]++; // counting frequency of 0-9 at cur_digit.
}
int cur = 0;
for (int i = 0; i < 10; ++i) {
int a = position[i];
position[i] = cur; // assingning starting position of 0-9.
cur += a;
}
std::vector<uint64_t> temp(n);
for (int i = 0; i < n; ++i) {
temp[position[(ar[i] / cur_digit) % 10]] =
ar[i]; // storing ar[i] in ar[i]'s cur_digit expected position of
// this step.
position[(ar[i] / cur_digit) %
10]++; // incrementing ar[i]'s cur_digit position by 1, as
// current place used by ar[i].
}
return temp;
}
std::vector::size
T size(T... args)
Here is the call graph for this function:

## tests()

static void tests | ( |  | ) |

static

Function to test the above algorithm.

Returns
  none

Test 1

Test 2

{
/// Test 1
std::vector<uint64_t> ar1 = {432, 234, 143, 332, 123};
ar1 = sorting::radix_sort::radix(ar1);
assert(std::is_sorted(ar1.begin(), ar1.end()));
/// Test 2
std::vector<uint64_t> ar2 = {213, 3214, 123, 111, 112, 142,
133, 132, 32, 12, 113};
ar2 = sorting::radix_sort::radix(ar2);
assert(std::is_sorted(ar2.begin(), ar2.end()));
}
std::is_sorted
T is_sorted(T... args)
sorting::radix_sort::radix
std::vector< uint64_t > radix(const std::vector< uint64_t > &ar)
Function to sort vector digit by digit.
Definition: radix_sort2.cpp:80
Here is the call graph for this function: