Radix sort example

Here given code implementation process.

//C Program
//Radix sort example
#include <stdio.h>
#include <stdlib.h>

//Return maximum element in given array
int maximum_element(int arr[],int size)
{

  int max_value=arr[0],min_value=arr[0];

  for (int i = 1; i < size; ++i)
  {
    if(max_value<arr[i])
    {
      max_value=arr[i];
    }
    if(min_value>arr[i])
    {
      min_value=arr[i];
    }

  }
  if(min_value<0 && -min_value > max_value)
  {
    max_value=-min_value;
  }

  return max_value;
}
//Display array elements
void display(int arr[],int size)
{
  for (int i = 0; i < size; ++i)
  {
    //Print array value of i location
    printf("  %d",arr[i] );
  }
  printf("\n");
}
void run_sort(int arr[],int slot[],int auxiliary[], int size,int mod)
{
  //set initial slot values
  for (int i = 0; i < 10; ++i)
  {
    slot[i]=0;
  }

  for (int i = 0; i < size; ++i)
  {
    if(arr[i]<0)
    {
      printf("\nThis Algorithm are not capable to work to negative numbers\n");
      return;
    }
    //set slot element
    slot[(arr[i]/mod)%10]++;
  }
  //update slot
  for (int i = 1; i < 10; ++i)
  {

    slot[i]+=slot[i-1];

  }
  for (int i = size-1; i >=0 ; --i)
  {
    
    auxiliary[ slot[ ( arr[i] / mod) %10 ]-1 ] = arr[i];
    slot[(arr[i] / mod)%10]--;
  }
  //Assign value of actual array
  for (int i = 0; i < size; ++i)
  {
    arr[i]=auxiliary[i];
  }

}
void radix_sort(int arr[],int size)
{
  //Get the maximum element of array
  int max_value=maximum_element(arr,size);


  int mod = 1;
  //allocated slot of 0 - 9 for positive number 
  int slot[10];

  //Allocate auxiliary space to perform radix sort
  int auxiliary[size];
 
  while(max_value!=0)
  {
   
    run_sort(arr,slot,auxiliary,size,mod);

    mod = mod*10;

    //remove last digit
    max_value /= 10;

  }

}
int main()
{
 
  //Define array elements
  int arr[]= {8,2,3,8,1,3,73,121,54,23,84,13,67,23,52};
  
  //Get the size of array elements
  int size=sizeof(arr)/sizeof(arr[0]);

  printf("Before Sort : \n");
  display(arr,size);
  radix_sort(arr,size);

  printf("After Sort : \n");
  display(arr,size);

 
  return 0;
}

Output

Before Sort :
  8  2  3  8  1  3  73  121  54  23  84  13  67  23  52
After Sort :
  1  2  3  3  8  8  13  23  23  52  54  67  73  84  121
/*
  C++ Program
  Radix sort example
*/
#include<iostream>

using namespace std;

class MySort {
	public:

		//Return maximum element in given array
		int maximum_element(int arr[], int size) {
			int max_value = arr[0], min_value = arr[0];
			for (int i = 1; i < size; ++i) {
				if (max_value < arr[i]) {
					max_value = arr[i];
				}
				if (min_value > arr[i]) {
					min_value = arr[i];
				}
			}
			if (min_value < 0 && -min_value > max_value) {
				max_value = -min_value;
			}
			return max_value;
		}
	//Display array elements
	void display(int arr[], int size) {
		for (int i = 0; i < size; ++i) {
			cout << " " << arr[i];
		}
		cout << "\n";
	}
	void run_sort(int arr[], int slot[], int auxiliary[], int size, int mod) {
		//set initial slot values

		for (int i = 0; i < 10; ++i) {
			slot[i] = 0;
		}
		for (int i = 0; i < size; ++i) {
			if (arr[i] < 0) {
				cout << "\nThis Algorithm are not capable to work to negative numbers\n";
				return;
			}
			//set slot element
			slot[(arr[i] / mod) % 10]++;
		}
		//update slot

		for (int i = 1; i < 10; ++i) {
			slot[i] += slot[i - 1];
		}
		for (int i = size - 1; i >= 0; --i) {
			auxiliary[slot[(arr[i] / mod) % 10] - 1] = arr[i];
			slot[(arr[i] / mod) % 10]--;
		}
		//Assign value of actual array

		for (int i = 0; i < size; ++i) {
			arr[i] = auxiliary[i];
		}
	}
	void radix_sort(int arr[], int size) {
		//Get the maximum element of array
		int max_value = this->maximum_element(arr, size);
		int mod = 1;
		int slot[10];
		int auxiliary[size];
		while (max_value != 0) {
			this->run_sort(arr, slot, auxiliary, size, mod);
			mod = mod *10;
			//remove last digit
			max_value /= 10;
		}
	}
};
int main() {
	MySort obj ;
	int arr[] = {
		8,
		2,
		3,
		8,
		1,
		3,
		73,
		121,
		54,
		23,
		84,
		13,
		67,
		23,
		52
	};
	//Get the size of array
	int size = sizeof(arr) / sizeof(arr[0]);
	cout << "Before Sort : \n";
	obj.display(arr, size);
	obj.radix_sort(arr, size);
	cout << "After Sort : \n";
	obj.display(arr, size);
	return 0;
}

Output

Before Sort :
 8 2 3 8 1 3 73 121 54 23 84 13 67 23 52
After Sort :
 1 2 3 3 8 8 13 23 23 52 54 67 73 84 121
/*
  Java Program
  Radix sort example
*/
public class MySort {


  //Return maximum element in given array
  public int maximum_element(int []arr,int size)
  {

    int max_value=arr[0],min_value=arr[0];

    for (int i = 1; i < size; ++i)
    {
      if(max_value<arr[i])
      {
        max_value=arr[i];
      }
      if(min_value>arr[i])
      {
        min_value=arr[i];
      }

    }
    if(min_value<0 && -min_value > max_value)
    {
      max_value=-min_value;
    }

    return max_value;
  }
  //Display array elements
  public void display(int []arr, int size)
  {
    for (int i = 0; i < size; ++i)
    {
      System.out.print("  "+arr[i] );
    }
    System.out.print("\n");
  }
  public void run_sort(int []arr,int []slot,int []auxiliary, int size,int mod)
  {
    //set initial slot values
    for (int i = 0; i < 10; ++i)
    {
      slot[i]=0;
    }

    for (int i = 0; i < size; ++i)
    {
      if(arr[i]<0)
      {
        System.out.print("\nThis Algorithm are not capable to work to negative numbers\n");
        return;
      }
      //set slot element
      slot[(arr[i]/mod)%10]++;
    }
    //update slot
    for (int i = 1; i < 10; ++i)
    {

      slot[i]+=slot[i-1];

    }
    for (int i = size-1; i >=0 ; --i)
    {
      
      auxiliary[ slot[ ( arr[i] / mod) %10 ]-1 ] = arr[i];
      slot[(arr[i] / mod)%10]--;
    }
    //Assign value of actual array
    for (int i = 0; i < size; ++i)
    {
      arr[i]=auxiliary[i];
    }

  }
  public void radix_sort(int []arr,int size)
  {
    //Get the maximum element of array
    int max_value=maximum_element(arr,size);


    int mod = 1;
    //allocated slot of 0 - 9 for positive number 
    int []slot= new int[10];

    //Allocate auxiliary space to perform radix sort
    int []auxiliary = new int[size];
   
    while(max_value!=0)
    {
     
      run_sort(arr,slot,auxiliary,size,mod);

      mod = mod*10;

      //remove last digit
      max_value /= 10;

    }

  }
  public static void main(String[] args) 
  {
  

    MySort obj = new MySort();
    //Define array elements
    int []arr= {8,2,3,8,1,3,73,121,54,23,84,13,67,23,52};
    //Get the size of array
    int size = arr.length;
    System.out.print("Before Sort : \n");
    obj.display(arr,size);

    obj.radix_sort(arr,size);
    System.out.print("After Sort : \n");
    obj.display(arr,size);

  }
}

Output

Before Sort :
 8 2 3 8 1 3 73 121 54 23 84 13 67 23 52
After Sort :
 1 2 3 3 8 8 13 23 23 52 54 67 73 84 121
/*
  C# Program
  Radix sort example
*/
using System;
public class MySort {
	//Return maximum element in given array
	public int maximum_element(int[] arr, int size) {
		int max_value = arr[0], min_value = arr[0];
		for (int i = 1; i < size; ++i) {
			if (max_value < arr[i]) {
				max_value = arr[i];
			}
			if (min_value > arr[i]) {
				min_value = arr[i];
			}
		}
		if (min_value < 0 && -min_value > max_value) {
			max_value = -min_value;
		}
		return max_value;
	}
	//Display array elements
	public void display(int[] arr, int size) {
		for (int i = 0; i < size; ++i) {
			Console.Write(" " + arr[i]);
		}
		Console.Write("\n");
	}
	public void run_sort(int[] arr, int[] slot, int[] auxiliary, int size, int mod) {
		//set initial slot values

		for (int i = 0; i < 10; ++i) {
			slot[i] = 0;
		}
		for (int i = 0; i < size; ++i) {
			if (arr[i] < 0) {
				Console.Write("\nThis Algorithm are not capable to work to negative numbers\n");
				return;
			}
			//set slot element
			slot[(arr[i] / mod) % 10]++;
		}
		//update slot

		for (int i = 1; i < 10; ++i) {
			slot[i] += slot[i - 1];
		}
		for (int i = size - 1; i >= 0; --i) {
			auxiliary[slot[(arr[i] / mod) % 10] - 1] = arr[i];
			slot[(arr[i] / mod) % 10]--;
		}
		//Assign value of actual array

		for (int i = 0; i < size; ++i) {
			arr[i] = auxiliary[i];
		}
	}
	public void radix_sort(int[] arr, int size) {
		//Get the maximum element of array
		int max_value = maximum_element(arr, size);
		int mod = 1;
      	//allocated slot of 0 - 9 for positive number 
		int[] slot = new int[10];
      	//Allocate auxiliary space to perform radix sort
		int[] auxiliary = new int[size];
		while (max_value != 0) {
			run_sort(arr, slot, auxiliary, size, mod);
			mod = mod * 10;
			//remove last digit
			max_value /= 10;
		}
	}
	public static void Main(String[] args) {
		MySort obj = new MySort();
		int[]
		//Define array elements
		arr = {
			8,
			2,
			3,
			8,
			1,
			3,
			73,
			121,
			54,
			23,
			84,
			13,
			67,
			23,
			52
		};
		//Get the size of array
		int size = arr.Length;
		Console.Write("Before Sort : \n");
		obj.display(arr, size);
		obj.radix_sort(arr, size);
		Console.Write("After Sort : \n");
		obj.display(arr, size);
	}
}

Output

Before Sort :
 8 2 3 8 1 3 73 121 54 23 84 13 67 23 52
After Sort :
 1 2 3 3 8 8 13 23 23 52 54 67 73 84 121
<?php
/*
  Php Program
  Radix sort example
*/
class MySort {
	//Return maximum element in given array

	public 	function maximum_element($arr, $size) {
		$max_value = $arr[0];
		$min_value = $arr[0];
		for ($i = 1; $i < $size; ++$i) {
			if ($max_value < $arr[$i]) {
				$max_value = $arr[$i];
			}
			if ($min_value > $arr[$i]) {
				$min_value = $arr[$i];
			}
		}
		if ($min_value < 0 && -$min_value > $max_value) {
			$max_value = -$min_value;
		}
		return $max_value;
	}
	//Display array elements

	public 	function display($arr, $size) {
		for ($i = 0; $i < $size; ++$i) {
			echo(" ". $arr[$i]);
		}
		echo("\n");
	}
	public 	function run_sort(&$arr, $slot, $auxiliary, $size, $mod) {
		//set initial slot values

		for ($i = 0; $i < 10; ++$i) {
			$slot[$i] = 0;
		}
		for ($i = 0; $i < $size; ++$i) {
			if ($arr[$i] < 0) {
				echo("\nThis Algorithm are not capable to work to negative numbers\n");
				return;
			}
			//set slot element
			$slot[(intval($arr[$i] / $mod)) % 10]++;
		}
		//update slot

		for ($i = 1; $i < 10; ++$i) {
			$slot[$i] += $slot[$i - 1];
		}
		for ($i = $size - 1; $i >= 0; --$i) {
			$auxiliary[$slot[(intval($arr[$i] / $mod)) % 10] - 1] = $arr[$i];
			$slot[(intval($arr[$i] / $mod)) % 10]--;
		}
		//Assign value of actual array

		for ($i = 0; $i < $size; ++$i) {
			$arr[$i] = $auxiliary[$i];
		}
	}
	public 	function radix_sort(&$arr, $size) {
		//Get the maximum element of array
		$max_value = $this->maximum_element($arr, $size);
		$mod = 1;
		//allocated slot of 0 - 9 for positive number 
		$slot = array_fill(0, 10, 0);
		//Allocate auxiliary space to perform radix sort
		$auxiliary = array_fill(0, $size, 0);
		while ($max_value != 0) {
			$this->run_sort($arr, $slot, $auxiliary, $size, $mod);
			$mod = $mod *10;
          	//remove last digit
			$max_value = intval($max_value / 10);
		}
	}
}

function main() {
	$obj = new MySort();
	//Define array elements
	$arr = array(8, 2, 3, 8, 1, 3, 73, 121, 54, 23, 84, 13, 67, 23, 52);
	//Get the size of array
	$size = count($arr);
	echo("Before Sort : \n");
	$obj->display($arr, $size);
	$obj->radix_sort($arr, $size);
	echo("After Sort : \n");
	$obj->display($arr, $size);

}
main();

Output

Before Sort :
 8 2 3 8 1 3 73 121 54 23 84 13 67 23 52
After Sort :
 1 2 3 3 8 8 13 23 23 52 54 67 73 84 121
/*
  Node Js Program
  Radix sort example
*/
class MySort {
	//Return maximum element in given array
	maximum_element(arr, size) {
		var max_value = arr[0];
		var min_value = arr[0];
		for (var i = 1; i < size; ++i) {
			if (max_value < arr[i]) {
				max_value = arr[i];
			}

			if (min_value > arr[i]) {
				min_value = arr[i];
			}
		}

		if (min_value < 0 && -min_value > max_value) {
			max_value = -min_value;
		}

		return max_value;
	}

	//Display array elements
	display(arr, size) {
		for (var i = 0; i < size; ++i) {
			process.stdout.write(" " + arr[i]);
		}

		process.stdout.write("\n");
	}
	run_sort(arr, slot, auxiliary, size, mod) {
		//set initial slot values

		for (var i = 0; i < 10; ++i) {
			slot[i] = 0;
		}

		for (var i = 0; i < size; ++i) {
			if (arr[i] < 0) {
				process.stdout.write("\nThis Algorithm are not capable to work to negative numbers\n");
				return;
			}

			//set slot element
			slot[(parseInt(arr[i] / mod)) % 10]++;
		}

		//update slot

		for (var i = 1; i < 10; ++i) {
			slot[i] += slot[i - 1];
		}

		for (var i = size - 1; i >= 0; --i) {
			auxiliary[slot[(parseInt(arr[i] / mod)) % 10] - 1] = arr[i];
			slot[(parseInt(arr[i] / mod)) % 10]--;
		}

		//Assign value of actual array

		for (var i = 0; i < size; ++i) {
			arr[i] = auxiliary[i];
		}
	}
	radix_sort(arr, size) {
		//Get the maximum element of array
		var max_value = this.maximum_element(arr, size);
		var mod = 1;
		//allocated slot of 0 - 9 for positive number 
		var slot = Array(10).fill(0);
		//Allocate auxiliary space to perform radix sort
		var auxiliary = Array(size).fill(0);
		while (max_value != 0) {
			this.run_sort(arr, slot, auxiliary, size, mod);
			mod = mod *10;
          	//remove last digit
			max_value = parseInt(max_value / 10);
		}
	}
}

function main(args) {
	var obj = new MySort();
	//Define array elements
	var arr = [8, 2, 3, 8, 1, 3, 73, 121, 54, 23, 84, 13, 67, 23, 52];
	//Get the size of array
	var size = arr.length;
	process.stdout.write("Before Sort : \n");
	obj.display(arr, size);
	obj.radix_sort(arr, size);
	process.stdout.write("After Sort : \n");
	obj.display(arr, size);
}

main();

Output

Before Sort :
 8 2 3 8 1 3 73 121 54 23 84 13 67 23 52
After Sort :
 1 2 3 3 8 8 13 23 23 52 54 67 73 84 121
# Python 3 Program
# Radix sort example
class MySort :
	# Return maximum element in given array
	def maximum_element(self, arr, size) :
		max_value = arr[0]
		min_value = arr[0]
		i = 1
		while (i < size) :
			if (max_value < arr[i]) :
				max_value = arr[i]
			
			if (min_value > arr[i]) :
				min_value = arr[i]
			
			i += 1
		
		if (min_value < 0 and - min_value > max_value) :
			max_value = -min_value
		
		return max_value
	
	# Display array elements
	def display(self, arr, size) :
		i = 0
		while (i < size) :
			print(" ", arr[i], end = "")
			i += 1
		
		print("\n", end = "")
	
	def run_sort(self, arr, slot, auxiliary, size, mod) :
		# set initial slot values
		i = 0
		while (i < 10) :
			slot[i] = 0
			i += 1
		
		i = 0
		while (i < size) :
			if (arr[i] < 0) :
				print("\nThis Algorithm are not capable to work to negative numbers\n", end = "")
				return
			
			# set slot element
			slot[(int(arr[i] / mod)) % 10] += 1
			i += 1
		
		# update slot
		i = 1
		while (i < 10) :
			slot[i] += slot[i - 1]
			i += 1
		
		i = size - 1
		while (i >= 0) :
			auxiliary[slot[(int(arr[i] / mod)) % 10] - 1] = arr[i]
			slot[(int(arr[i] / mod)) % 10] -= 1
			i -= 1
		
		# Assign value of actual array
		i = 0
		while (i < size) :
			arr[i] = auxiliary[i]
			i += 1
		
	
	def radix_sort(self, arr, size) :
		max_value = self.maximum_element(arr, size)
		mod = 1
		slot = [0] * 10
		auxiliary = [0] * size
		while (max_value != 0) :
			self.run_sort(arr, slot, auxiliary, size, mod)
			mod = mod * 10
			# remove last digit
			max_value = int(max_value / 10)
		
	

def main() :
	obj = MySort()
	arr = [8, 2, 3, 8, 1, 3, 73, 121, 54, 23, 84, 13, 67, 23, 52]
	size = len(arr)
	print("Before Sort : \n", end = "")
	obj.display(arr, size)
	obj.radix_sort(arr, size)
	print("After Sort : \n", end = "")
	obj.display(arr, size)


if __name__ == "__main__":
	main()

Output

Before Sort :
  8  2  3  8  1  3  73  121  54  23  84  13  67  23  52
After Sort :
  1  2  3  3  8  8  13  23  23  52  54  67  73  84  121
#   Ruby Program
#   Radix sort example
class MySort 
	# Return maximum element in given array
	def maximum_element(arr, size) 
		max_value = arr[0]
		min_value = arr[0]
		i = 1
		while (i < size) 
			if (max_value < arr[i]) 
				max_value = arr[i]
			end
			if (min_value > arr[i]) 
				min_value = arr[i]
			end
			i += 1
		end
		if (min_value < 0 && -min_value > max_value) 
			max_value = -min_value
		end
		return max_value
	end
	# Display array elements
	def display(arr, size) 
		i = 0
		while (i < size) 
			print(" ", arr[i])
			i += 1
		end
		print("\n")
	end
	def run_sort(arr, slot, auxiliary, size, mod) 
		# set initial slot values
		i = 0
		while (i < 10) 
			slot[i] = 0
			i += 1
		end
		i = 0
		while (i < size) 
			if (arr[i] < 0) 
				print("\nThis Algorithm are not capable to work to negative numbers\n")
				return
			end
			# set slot element
			slot[(arr[i] / mod) % 10] += 1
			i += 1
		end
		# update slot
		i = 1
		while (i < 10) 
			slot[i] += slot[i - 1]
			i += 1
		end
		i = size - 1
		while (i >= 0) 
			auxiliary[slot[(arr[i] / mod) % 10] - 1] = arr[i]
			slot[(arr[i] / mod) % 10] -= 1
			i -= 1
		end
		# Assign value of actual array
		i = 0
		while (i < size) 
			arr[i] = auxiliary[i]
			i += 1
		end
	end
	def radix_sort(arr, size) 
		max_value = self.maximum_element(arr, size)
		mod = 1
		slot = Array.new(10, 0)
		auxiliary = Array.new(size, 0)
		while (max_value != 0) 
			self.run_sort(arr, slot, auxiliary, size, mod)
			mod = mod * 10
			# remove last digit
			max_value /= 10
		end
	end
end
def main() 
	obj = MySort.new()
	arr = [8, 2, 3, 8, 1, 3, 73, 121, 54, 23, 84, 13, 67, 23, 52]
	size = arr.length
	print("Before Sort  :\n")
	obj.display(arr, size)
	obj.radix_sort(arr, size)
	print("After Sort  :\n")
	obj.display(arr, size)
end
main()

Output

Before Sort  :
 8 2 3 8 1 3 73 121 54 23 84 13 67 23 52
After Sort  :
 1 2 3 3 8 8 13 23 23 52 54 67 73 84 121
/*
  Scala Program
  Radix sort example
*/
class MySort {
	//Return maximum element in given array
	def maximum_element(arr: Array[Int], size: Int): Int = {
		var max_value: Int = arr(0);
		var min_value: Int = arr(0);
		var i: Int = 1;
		while (i < size) {
			if (max_value < arr(i)) {
				max_value = arr(i);
			}
			if (min_value > arr(i)) {
				min_value = arr(i);
			}
			i += 1;
		}
		if (min_value < 0 && -min_value > max_value) {
			max_value = -min_value;
		}
		return max_value;
	}
	//Display array elements
	def display(arr: Array[Int], size: Int): Unit = {
		var i: Int = 0;
		while (i < size) {
			print(" " + arr(i));
			i += 1;
		}
		print("\n");
	}
	def run_sort(arr: Array[Int], slot: Array[Int], auxiliary: Array[Int], size: Int, mod: Int): Unit = {
		//set initial slot values
		var i: Int = 0;
		while (i < 10) {
			slot(i) = 0;
			i += 1;
		}
		i = 0;
		while (i < size) {
			if (arr(i) < 0) {
				print("\nThis Algorithm are not capable to work to negative numbers\n");

				return;
			}
			//set slot element
			slot(((arr(i) / mod).toInt) % 10) += 1;
			i += 1;
		}
		//update slot
		i = 1;
		while (i < 10) {
			slot(i) += slot(i - 1);
			i += 1;
		}
		i = size - 1;
		while (i >= 0) {
			auxiliary(slot(((arr(i) / mod).toInt) % 10) - 1) = arr(i);
			slot(((arr(i) / mod).toInt) % 10) -= 1;
			i -= 1;
		}
		//Assign value of actual array
		i = 0;
		while (i < size) {
			arr(i) = auxiliary(i);
			i += 1;
		}
	}
	def radix_sort(arr: Array[Int], size: Int): Unit = {
		var max_value: Int = this.maximum_element(arr, size);
		var mod: Int = 1;
		val slot: Array[Int] = Array.fill[Int](10)(0);
		val auxiliary: Array[Int] = Array.fill[Int](size)(0);
        while (max_value != 0) {
            this.run_sort(arr, slot, auxiliary, size, mod);
            mod = mod * 10;
          //remove last digit
            max_value = (max_value / 10).toInt;
        }
    }
}
object Main {
	def main(args: Array[String]): Unit = {
		val obj: MySort = new MySort();
		var arr: Array[Int] = Array(8, 2, 3, 8, 1, 3, 73, 121, 54, 23, 84, 13, 67, 23, 52);
		val size: Int = arr.length;
		print("Before Sort : \n");
		obj.display(arr, size);
		obj.radix_sort(arr, size);
		print("After Sort : \n");
		obj.display(arr, size);
	}
}

Output

Before Sort :
 8 2 3 8 1 3 73 121 54 23 84 13 67 23 52
After Sort :
 1 2 3 3 8 8 13 23 23 52 54 67 73 84 121
/*
  Swift Program
  Radix sort example
*/
class MySort {
	//Return maximum element in given array
	func maximum_element(_ arr: [Int], _ size: Int) -> Int {
		var max_value: Int = arr[0];
		var min_value: Int = arr[0];
		var i: Int = 1;
		while (i < size) {
			if (max_value < arr[i]) {
				max_value = arr[i];
			}
			if (min_value > arr[i]) {
				min_value = arr[i];
			}
			i += 1;
		}
		if (min_value < 0 && -min_value > max_value) {
			max_value = -min_value;
		}
		return max_value;
	}
	//Display array elements
	func display(_ arr: [Int], _ size: Int) {
		var i: Int = 0;
		while (i < size) {
			print(" ", arr[i], terminator: "");
			i += 1;
		}
		print("\n", terminator: "");
	}
	func run_sort(_ arr: inout [Int], _ slot: inout [Int], _ auxiliary: inout [Int], _ size: Int, _ mod: Int) {
		//set initial slot values
		var i: Int = 0;
		while (i < 10) {
			slot[i] = 0;
			i += 1;
		}
		i = 0;
		while (i < size) {
			if (arr[i] < 0) {
				print("\nThis Algorithm are not capable to work to negative numbers\n", terminator: "");
				return;
			}
			//set slot element
			slot[(arr[i] / mod) % 10] += 1;
			i += 1;
		}
		//update slot
		i = 1;
		while (i < 10) {
			slot[i] += slot[i - 1];
			i += 1;
		}
		i = size - 1;
		while (i >= 0) {
			auxiliary[slot[(arr[i] / mod) % 10] - 1] = arr[i];
			slot[(arr[i] / mod) % 10] -= 1;
			i -= 1;
		}
		//Assign value of actual array
		i = 0;
		while (i < size) {
			arr[i] = auxiliary[i];
			i += 1;
		}
	}
	func radix_sort(_ arr: inout [Int], _ size: Int) {
		var max_value: Int = self.maximum_element(arr, size);
		var mod: Int = 1;
		var slot: [Int] = Array(repeating: 0, count: 10);
		var auxiliary: [Int] = Array(repeating: 0, count: size);
        while (max_value != 0) {
            self.run_sort(&arr, &slot, &auxiliary, size, mod);
            mod = mod * 10;
            //remove last digit
            max_value /= 10;
        }
	}
}
func main() {
	let obj: MySort = MySort();
	var arr: [Int] = [8, 2, 3, 8, 1, 3, 73, 121, 54, 23, 84, 13, 67, 23, 52];
	let size: Int = arr.count;
	print("Before Sort : \n", terminator: "");
	obj.display(arr, size);
	obj.radix_sort(&arr, size);
	print("After Sort : \n", terminator: "");
	obj.display(arr, size);
}
main();

Output

Before Sort :
  8  2  3  8  1  3  73  121  54  23  84  13  67  23  52
After Sort :
  1  2  3  3  8  8  13  23  23  52  54  67  73  84  121


Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment







© 2021, kalkicode.com, All rights reserved