Не работает MargeSort. Не понимаю в чем проблема

#include<iostream>
#include<ctime>
#include<time.h>
#include<iomanip>
using namespace std;
 
void FillArray(int*, const int);
void CoutArray(int*, const int);
void copyingArray(int*, int*, const int);
////////InsertionSort//////////
int InsertionSort(int*, int);
//////  MergeSort /////////
void marge(int*, int, int, int );
void mergeSort(int*, int, int);
//////  ShellSort /////////
int shellSort(int*, int);
 
int main()
{
    setlocale(LC_ALL, "Rus");
    srand(time(NULL));
    
    int SIZE;
    cout << "Введите количество элементо массива" << endl;
    cin >> SIZE;
    int* arr = new int[SIZE];
    FillArray(arr, SIZE);
    CoutArray(arr, SIZE);
    cout << endl;
    int* arr2 = new int[SIZE];
    int* arr3 = new int[SIZE];
 
    copyingArray(arr, arr2, SIZE);
    copyingArray(arr, arr3, SIZE);
 
    ////////InsertionSort//////////
    unsigned long t, t1;
    t = clock();
    InsertionSort(arr, SIZE);
    t1 = clock() - t;
    cout << fixed << "Час виконання сортування InsertionSort: " << ((double)t1) / CLOCKS_PER_SEC << " секунд" << endl;
    cout << "InsertionSort: \n";
    CoutArray(arr, SIZE);
    cout << endl;
 
    //////  MergeSort /////////
    unsigned long t2, t3;
    t2 = clock();
    mergeSort(arr2, 0, (sizeof(*arr)/sizeof(int)) - 1);
    t3 = clock() - t2;
    cout << fixed << "Час виконання сортування Marge Sort: " << ((double)t3) / CLOCKS_PER_SEC << " секунд" << endl;
    cout << "Marge Sort: \n";
    CoutArray(arr2, SIZE);
    cout << endl;
 
    //////  ShellSort /////////
    unsigned long t4, t5;
    t4 = clock();
    shellSort(arr3, SIZE);
    t5 = clock() - t4;
    cout << fixed << "Час виконання сортування ShellSort: " << ((double)t5) / CLOCKS_PER_SEC << " секунд" << endl;
    cout << "ShellSort: " "\n";
    CoutArray(arr3, SIZE);
    cout << endl;
    
    
    delete[] arr;
    arr = nullptr;
    delete[] arr2;
    arr2 = nullptr;
    delete[] arr3;
    arr3 = nullptr;
    return 0;
}
 
void FillArray(int* arr, const int SIZE) 
{
    for (int i = 0; i < SIZE; i++) {
        arr[i] = rand() % 65535;
    }
}
void CoutArray(int* arr, const int SIZE) 
{
    for (int i = 0; i < SIZE; i++) {
        cout << setw(7) << arr[i];
    }
    cout << endl;
}
 
void copyingArray(int* arr, int* arr2, const int SIZE) 
{
    for (int i = 0; i < SIZE; i++) {
        arr2[i] = arr[i];
    }
}
 
 
//InsertionSort
int InsertionSort(int* arr, int SIZE)
{
    int i, key, j;
    for (i = 1; i < SIZE; i++)
    {
        key = arr[i];
        j = i - 1;
 
        /* Перемістити елементи arr[0..i-1], тобто
         більше, ніж key, на одну позицію попереду
         їхнього поточного положення */
        while (j >= 0 && arr[j] > key)
        {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
    return 0;
}
 
////////////////////////  MergeSort ////////////////////////////////////////
 
void marge(int* arr2, int p, int q, int r)
{
    const int n1 = q - p + 1;
    const int n2 = r - q;
 
    int* L; int* R;
    L = new int[n1 + 1];
    R = new int[n2 + 1];
 
    for (int i = 0; i < n1; i++)
    {
        L[i] = arr2[p + i];
    }
 
    for (int j = 0; j < n2; j++)
    {
        R[j] = arr2[q + 1 + j];
    }
    
 
    // Сохранение текущего индекса подмассивов и основного массива
    int i, j, k;
    i = 0;
    j = 0;
    k = p;
 
    while (i < n1 && j < n2)
    {
        if (L[i] <= R[j])
        {
            arr2[k] = L[i];
            i++;
        }
        else
        {
            arr2[k] = R[j];
            j++;
        }
        k++;
    }
 
    // Когда у нас заканчиваются элементы в L или M,
    // забираем оставшиеся элементы и вставляем A [p..r]
 
    while (i < n1)
    {
        arr2[k] = L[i];
        i++;
        k++;
    }
 
    while (j < n2)
    {
        arr2[k] = R[j];
        j++;
        k++;
    }
    delete[] L; delete[] R;
}
// Разделить массив на два подмассива, отсортировать их и объединить
void mergeSort(int* arr2, int p, int r)
{
    if (p < r)
    {
        // m - это точка, в которой массив разделен на два подмассива
        int m = p + (r - p) / 2;
 
        mergeSort(arr2, p, m);
        mergeSort(arr2, m + 1, r);
        // Объединение отсортированных подмассивов
        marge(arr2, p, m , r);
    }
}
////////////////////////  ShellSort ////////////////////////////////////////
int shellSort(int* arr3, int SIZE)
{
    for (int gap = SIZE/2; gap > 0; gap /= 2)
    {
        for (int i = gap; i < SIZE; i+=1)
        {
            int temp = arr3[i];
            int j;
            for (j = i; j >= gap && arr3[j - gap] > temp; j -= gap)
                arr3[j] = arr3[j - gap];
 
            arr3[j] = temp;
        }
    }
    return 0;
}