added impl for radix sort need to debug

src/data_structures/stack.rs

@@ -1,8 +1,9 @@
+#[derive(Debug)]
 pub struct Stack<T> {
     stack: Vec<T>,
 }
 
-impl<T> Stack<T> {
+impl<T: Copy> Stack<T> {
     pub fn new() -> Self {
         Stack { stack: Vec::new() }
     }
@@ -22,3 +23,12 @@ impl<T> Stack<T> {
         self.stack.last()
     }
 }
+
+impl<T: Copy> IntoIterator for Stack<T> {
+    type Item = T;
+    type IntoIter = std::vec::IntoIter<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.stack.into_iter()
+    }
+}

src/main.rs

@@ -71,6 +71,14 @@ fn merge_sort_demo(){
     println!("Array before merge sort: {:?}",arr);
     println!("Array after merge sort: {:?}",merge_sort::merge_sort(arr));
 }
+fn radix_sort_demo(){
+    println!("-------------------");
+    println!("RADIX SORT DEMO:");
+    println!("-------------------");
+    let arr = &[9, 3, 7, 4, 69, 420, 42];
+    println!("Array before radix sort: {:?}",arr);
+    println!("Array after radix sort: {:?}",radix_sort::radix_sort(arr));
+}
 fn main() {
     println!("");
     println!("|~~~~~~~~~~~~~~~|");
@@ -87,4 +95,5 @@ fn main() {
     quick_sort_demo();
     bubble_sort_demo();
     merge_sort_demo();
+    radix_sort_demo();
 }

src/radix_sort.rs

@@ -1,3 +1,46 @@
-pub fn radix_sort(){
+use crate::data_structures::stack::Stack;
+pub fn radix_sort(arr: &[u64]) -> Vec<u64> {
+    let mut buckets: [Stack<u64>; 10] = [
+        Stack::new(),
+        Stack::new(),
+        Stack::new(),
+        Stack::new(),
+        Stack::new(),
+        Stack::new(),
+        Stack::new(),
+        Stack::new(),
+        Stack::new(),
+        Stack::new(),
+    ];
+    let mut sort_vec = arr.to_vec();
+    let largest_place_value = get_largest_place(arr);
 
+    for counter in 0..largest_place_value {
+        for num in &sort_vec {
+            let digit = get_digit(*num, counter as usize);
+            buckets[digit].push(*num);
+        }
+
+        let mut index = 0;
+        for stack in &mut buckets {
+            while let Some(value) = stack.pop() {
+                sort_vec[index] = value;
+                index += 1;
+            }
+        }
+    }
+
+    sort_vec
+}
+
+fn get_digit(num: u64, place: usize) -> usize {
+    (num / 10u64.pow(place as u32)) as usize % 10
+}
+
+
+fn get_largest_place(arr: &[u64]) -> usize {
+    arr.iter()
+        .map(|&num| (num as f64).log(10.0).ceil() as usize)
+        .max()
+        .unwrap_or(0)
 }