complete the quick sort and insertion sort functions only without modifying the rest of the code:

import java.util.concurrent.ThreadLocalRandom;

class ProgrammingAssignment$1\{$

$//$Function to swap two integers without pass by reference since Java is pass$-$by$-$value only

static int swapHelper$($int a$,$ int b$)\{$

return a;

$\}$

$//$Function to compute the median of three numbers. Used to benchmark runtimes fo sorting algorithms.

static int medianof$3($long a$,$ long b$,$ long c$)\{$

if $($a $<$ c$)$

$\{$

if $($b $<$ a$)$

return $1$;

else if $($c $<$ b$)$

return $3$;

else

return $2$;

$\}$

else if $($b $<$ c$)$

return $3$;

else if $($a $<$ b$)$

return $1$;

else

return $2$;

$\}$

$//$Check if the array is sorted. Used to check the correctness of the sorting algorithm implementations.

static boolean isSorted$($int$[]$ arr, int n$)$

$\{$

for $($int i $=0$; i $<$ n$-1$; i$++)$

if $($arr$[$i$+1]<$ arr$[$i$])$

return false;

return true;

$\}$

$//$Function to generate a sorted array of size n$.$

static int$[]$ sortedArray$($int n$)\{$

int$[]$ data $=$ new int$[$n$]$;

for $($int i $=0$; i $<$ n; i$++)$

data$[$i$]=$ i$+1$;

return data;

$\}$

$//$ Function to generate an array of size n filled with constants $($zero in this case$)$

static int$[]$ constArray$($int n$)\{$

int$[]$ data $=$ new int$[$n$]$;

return data;

$\}$

$//$ Function to generate a random array of size n$.$

static int$[]$ randomArray$($int n$)\{$

int$[]$ data $=$ sortedArray$($n$)$;

for $($int i $=$ n; i $>1$; i$--)$

$\{$

int swap $=$ ThreadLocalRandom.current$().$nextInt$(0,1000)\%$ i;

data$[$swap$]=$ swapHelper$($data$[$i$-1],$ data$[$i$-1]=$data$[$swap$])$;

$\}$

return data;

$\}$

$//$ Function to implement Selection Sort.

$//$ Input Arguments $-$ data: array to sort, n: number of elements in array

$//$ Output: Sorted array $($Ascending Order$).$

static int$[]$ selectionSort$($int$[]$ data, int n$)\{$

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

int curr$\_$max $=$ i;

for$($int k$=$i$+1$; k data$[$k$])$

curr$\_$max $=$ k;

$\}$

data$[$curr$\_$max$]=$ swapHelper$($data$[$i$],$ data$[$i$]=$data$[$curr$\_$max$])$;

$\}$

return data;

$\}$

$//$ Helper function for merge sort

static int$[]$ mergeFn$($int$[]$ data, int left, int mid, int right$)\{$

int n$1=$ mid $-$ left $+1$;

int n$2=$ right $-$ mid;

int leftArr$[]=$ new int$[$n$1]$;

int rightArr$[]=$ new int$[$n$2]$;

for $($int i $=0$; i $<$ n$1$; $++$i$)$

leftArr$[$i$]=$ data$[$left $+$ i$]$;

for $($int j $=0$; j $<$ n$2$; $++$j$)$

rightArr$[$j$]=$ data$[$mid $+1+$ j$]$;

int i $=0,$ j $=0$;

int k $=$ left;

while $($i $<$ n$1$ && j $<$ n$2)\{$

if $($leftArr$[$i$]<=$ rightArr$[$j$])\{$

data$[$k$]=$ leftArr$[$i$]$;

i$++$;

$\}$

else $\{$

data$[$k$]=$ rightArr$[$j$]$;

j$++$;

$\}$

k$++$;

$\}$

while $($i $<$ n$1)\{$

data$[$k$]=$ leftArr$[$i$]$;

i$++$;

k$++$;

$\}$

while $($j $<$ n$2)\{$

data$[$k$]=$ rightArr$[$j$]$;

j$++$;

k$++$;

$\}$

return data;

$\}$

$//$ Function to implement Merge Sort.

$//$ Input Arguments $-$ data: array to sort, n: number of elements in array

$//$ Output: Sorted array $($Ascending Order$).$

static int$[]$ mergeSort$($int$[]$ data, int left, int right$)\{$

if$($left $<$ right$)\{$

int mid $=($left $+$ right$)/2$;

data $=$ mergeSort$($data$,$ left, mid$)$;

data $=$ mergeSort$($data$,$ mid $+1,$ right$)$;

data $=$ mergeFn$($data$,$ left, mid, right$)$;

$\}$

return data;

$\}$

$//$ Function to implement Quick Sort.

$//$ Input Arguments $-$ data: array to sort, n: number of elements in array

$//$ Output: Sorted array $($Ascending Order$).$

static int$[]$ quickSort$($int$[]$ data, int n$)\{$

$//$TODO: Your implementation of Quick Sort comes here.

return data;

$\}$

$//$ Function to implement Insertion Sort.

$//$ Input Arguments $-$ data: array to sort, n: number of elements in array

$//$ Output: Sorted array $($Ascending Order$).$

static int$[]$ insertionSort$($int$[]$ data, int n$)\{$

$//$TODO: Your implementation of Insertion Sort comes here.

return data;

$\}$