rewrite this code with cutoff value public static void main$($String$[]$ args$)\{$

int choice;

int number;

int$[]$ array;

Scanner input $=$ new Scanner$($System$.$in$)$;

System.out.println$("$Choose a sorting routine:"$)$;

System.out.println$("1.$ Insertion Sort"$)$;

System.out.println$("2.$ Shell Sort"$)$;

System.out.println$("3.$ Merge Sort"$)$;

System.out.println$("4.$ Quick Sort"$)$;

choice $=$ input.nextInt$()$;

System.out.print$("$Enter the number of integers: $")$;

number $=$ input.nextInt$()$;

array $=$ new int$[$number$]$;

System.out.println$("$Enter the $"+$ number $+"$ integers:"$)$;

for $($int i $=0$; i $<$ number; i$++)\{$

array$[$i$]=$ input.nextInt$()$;

$\}$

switch $($choice$)\{$

case $1$:

insertion$\_$sort$($array$)$;

break;

case $2$:

shell$\_$sort$($array$)$;

break;

case $3$:

array $=$ merge$\_$sort$($array$)$;

break;

case $4$:

quick$\_$sort$($array$,0,$ array.length $-1)$;

break;

default:

System.out.println$("$Invalid choice"$)$;

return;

$\}$

int count;

count $=$ remove$\_$duplicate$($array$)$;

System.out.println$("$The resulting array is:$")$;

for $($int i $=0$; i $<$ count; i$++)\{$

System.out.print$($array$[$i$]+"")$;

$\}$

$\}$

public static void insertion$\_$sort$($int$[]$ array$)\{$

int key;

int j;

for $($int i $=1$; i $<$ array.length; i$++)\{$

key $=$ array$[$i$]$;

j $=$ i $-1$;

while $($j $>=0$ && array$[$j$]>$ key$)\{$

array$[$j $+1]=$ array$[$j$]$;

j$--$;

$\}$

array$[$j $+1]=$ key;

$\}$

$\}$

public static void shell$\_$sort$($int$[]$ array$)\{$

int number;

int j;

int temporary;

number $=$ array.length;

for $($int gap $=$ number $/2$; gap $>0$; gap $/=2)\{$

for $($int i $=$ gap; i $<$ number; i$++)\{$

temporary $=$ array$[$i$]$;

for $($j $=$ i; j $>=$ gap && array$[$j $-$ gap$]>$ temporary; j $-=$ gap$)\{$

array$[$j$]=$ array$[$j $-$ gap$]$;

$\}$

array$[$j$]=$ temporary;

$\}$

$\}$

$\}$

public static int$[]$ merge$\_$sort$($int$[]$ array$)\{$

int middle;

int$[]$ left;

int$[]$ right;

if $($array$.$length $<=1)$ return array;

middle $=$ array.length $/2$;

left $=$ new int$[$middle$]$;

right $=$ new int$[$array$.$length $-$ middle$]$;

System.arraycopy$($array$,0,$ left, $0,$ middle$)$;

System.arraycopy$($array$,$ middle, right, $0,$ array.length $-$ middle$)$;

left $=$ merge$\_$sort$($left$)$;

right $=$ merge$\_$sort$($right$)$;

return merge$($left$,$ right$)$;

$\}$

public static int$[]$ merge$($int$[]$ left, int$[]$ right$)\{$

int$[]$ result;

int i;

int j;

int k;

result $=$ new int$[$left$.$length $+$ right.length$]$;

i $=0$;

j $=0$;

k $=0$;

while $($i $<$ left.length && j $<$ right.length$)\{$

if $($left$[$i$]<=$ right$[$j$])\{$

result$[$k$++]=$ left$[$i$++]$;

$\}$ else $\{$

result$[$k$++]=$ right$[$j$++]$;

$\}$

$\}$

while $($i $<$ left.length$)\{$

result$[$k$++]=$ left$[$i$++]$;

$\}$

while $($j $<$ right.length$)\{$

result$[$k$++]=$ right$[$j$++]$;

$\}$

return result;

$\}$

public static void quick$\_$sort$($int$[]$ array, int low, int high$)\{$

int pivot$\_$index;

if $($low $<$ high$)\{$

pivot$\_$index $=$ partition$($array$,$ low, high$)$;

quick$\_$sort$($array$,$ low, pivot$\_$index $-1)$;

quick$\_$sort$($array$,$ pivot$\_$index $+1,$ high$)$;

$\}$

$\}$

public static int partition$($int$[]$ array, int low, int high$)\{$

int pivot;

int i;

pivot $=$ array$[$high$]$;

i $=$ low $-1$;

for $($int j $=$ low; j $<$ high; j$++)\{$

if $($array$[$j$]<=$ pivot$)\{$

i$++$;

swap$($array$,$ i$,$ j$)$;

$\}$

$\}$

swap$($array$,$ i $+1,$ high$)$;

return i $+1$;

$\}$

public static void swap$($int$[]$ array, int i$,$ int j$)\{$

int temporary;

temporary $=$ array$[$i$]$;

array$[$i$]=$ array$[$j$]$;

array$[$j$]=$ temporary;

$\}$

public static int remove$\_$duplicate$($int$[]$ array$)\{$

int index;

if $($array$.$length $==0)$ return $0$;

index $=0$;

for $($int i $=1$; i $<$ array.length; i$++)\{$

if $($array$[$i$]!=$ array$[$index$])\{$

index$++$;

array$[$index$]=$ array$[$i$]$;

$\}$

$\}$

return index $+1$;

$\}$

$\}$