Sorting algorithms

#include <iostream>
#include <fstream>
#include <time.h>

using namespace std;

int* BubbleSort(int arr[], int arraysize);
int* QuickSort(int arr[], int left, int right);
int* RadixSort(int arr[], int arraysize);

int main()
{
    int arraysize;
    cout << "Enter the array size: ";
    cin >> arraysize;

    int timer_start, timer_end, bubble_time, quick_time, radix_time;
    int bubblearr[arraysize], quickarr[arraysize], radixarr[arraysize];

    ifstream file_bubble, file_quick, file_radix;
    file_bubble.open("unsorted bubble.txt");
    file_quick.open("unsorted quick.txt");
    file_radix.open("unsorted radix.txt");

    for(int i = 0; i < arraysize; i++){
        file_bubble >> bubblearr[i];
        file_quick >> quickarr[i];
        file_radix >> radixarr[i];
    }

    timer_start = clock();
    BubbleSort(bubblearr, arraysize);
    timer_end = clock();
    bubble_time = (timer_end - timer_start) / CLOCKS_PER_SEC;

    timer_start = clock();
    QuickSort(quickarr, 0, arraysize);
    timer_end = clock();
    quick_time = (timer_end - timer_start) / CLOCKS_PER_SEC;

    timer_start = clock();
    RadixSort(radixarr, arraysize);
    timer_end = clock();
    radix_time = (timer_end - timer_start) / CLOCKS_PER_SEC;

    cout << "Sorting is done, the execution times were:\nBubblesort: " << bubble_time << "\nQuicksort: " << quick_time << "\nRadixsort: " << radix_time;

    ofstream file_out;
    file_out.open("sorted.csv");
    file_out << "Bubblesort,Quicksort,Radixsort\n," << bubble_time << "," << quick_time << "," << radix_time << endl;
    for(int i = 0; i < arraysize; i++){
        file_out << bubblearr[i] << "," << quickarr[i] << "," << radixarr[i] << endl;
    }

    file_bubble.close();
    file_quick.close();
    file_radix.close();
    file_out.close();

    return 0;
}

int* BubbleSort(int arr[], int arraysize)
{
    bool swapped = true;
    int j = 0;
    int temp;
    while(swapped){
        swapped = false;
        j++;
        for (int i = 0; i < arraysize - j; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
                swapped = true;
            }
        }
    }
    return arr;
}

int* QuickSort(int arr[], int left, int right)
{
    int i = left, j = right;
    int temp;
    int pivot = arr[(left + right) / 2];

    //partitie
    while (i <= j){
        while (arr[i] < pivot){
            i++;
        }
        while (arr[j] > pivot){
            j--;
        }
        if (i <= j){
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }

    //recursie
    if(left < j){
        QuickSort(arr, left, j);
    }
    if(i < right){
        QuickSort(arr, i, right);
    }

    return arr;
}

int* RadixSort(int arr[], int arraysize)
{
    //Sorteer loop
    int output[arraysize];
    int i, j;

    int n = arr[0];
    for(i = 1; i < arraysize; i++){
        if(arr[i] > n){
            n = arr[i];
        }
    }

    for(i = 1; n / i > 0; i *= 10){
        int digit[10] = {0};
        for(j = 0; j < arraysize; j++){
            digit[(arr[j] / i) % 10]++;  //categoriseer getallen
        }
        for(j = 1; j < 10; j++){
            digit[j] += digit[j - 1];
        }

        for(j = arraysize - 1; j >= 0; j--){
            output[digit[(arr[j] / i) % 10] - 1] = arr[j];
            digit[(arr[j] / i) % 10]--;
        }

        for(j = 0; j < arraysize; j++){
            arr[j] = output[j];
        }
    }
    return arr;
}