# Radix Sort

Radix Sort is a linear sorting algorithm that operates by sorting the elements of a list based on the individual digits of their decimal representation. The algorithm first sorts the elements based on the least significant digit (LSD) and then moves on to sorting the elements based on the next most significant digit, and so on, until all digits have been considered. Radix sort is most commonly used to sort integers and is particularly effective when the elements have a large number of digits and the elements are not evenly distributed across the digits.

Radix sort operates in two stages: first, it sorts the elements based on the LSD using a stable sorting algorithm, such as counting sort, and then it moves on to sorting the elements based on the next most significant digit. The algorithm repeats this process until all digits have been considered.

The time complexity of radix sort is O(d * (n + b)), where d is the number of digits in the largest element in the list, n is the number of elements in the list, and b is the base of the number system being used. For example, if the elements are decimal numbers, the base is 10. The space complexity of radix sort is O(n + b), as it requires a separate counting array for each digit.

Here is a code example of the radix sort algorithm in Python:

```
def radix_sort(arr):
max_num = max(arr)
max_num_digits = len(str(max_num))
for i in range(max_num_digits):
arr = counting_sort(arr, i)
return arr
def counting_sort(arr, digit):
n = len(arr)
output = [0] * n
count = [0] * 10
for i in arr:
index = get_digit(i, digit)
count[index] += 1
for i in range(1, 10):
count[i] += count[i - 1]
for i in range(n - 1, -1, -1):
index = get_digit(arr[i], digit)
output[count[index] - 1] = arr[i]
count[index] -= 1
return output
def get_digit(num, digit):
return (num // (10 ** digit)) % 10
```

The radix_sort function takes a list arr as an argument and first determines the maximum number in the list and the number of digits in the maximum number. The function then performs the radix sort by sorting the elements based on each digit of their decimal representation, starting with the LSD.

The counting_sort function is used to sort the elements based on each digit of their decimal representation. The function takes a list arr and the current digit digit as arguments. The function first initializes a counting array count of size 10 and counts the occurrences of each digit in the current digit position. The function then performs a counting sort on the elements based on the counts in the counting array.

The get_digit function is used to extract the specified digit from each element in the list. The function takes a number num and the current digit digit as arguments and returns the digit in the specified position by dividing the number by the power of 10 equal to the digit position and taking the remainder when divided by 10.

In conclusion, Radix Sort is a fast and efficient sorting algorithm that is well suited for sorting