Как можно вычислить количество используемой алгоритмом дополнительной памяти? С++

Есть функции разных методов сортировок. Нужно вычислить количество используемой алгоритмом дополнительной памяти для каждого метода. Видел что через new и delete как-то можно, но то ли это будет.

#include <iostream>
#include <chrono>
#include <math.h>
using namespace std;
const int RUN = 32;


void InsertionSort(int arr[], const int n, int & basic_assignments, int & assitiev_assignments,
    chrono::duration<float> & time) {

    auto start = chrono::high_resolution_clock::now();

    basic_assignments = 0;
    assitiev_assignments = 0;
    
    for (int i = 1; i < n; i++)
    {

        int x = arr[i];
        int j = i;

        while ((j > 0) && (arr[j - 1] > x)) {
            arr[j] = arr[j - 1];
            j--;

            basic_assignments += 1;
            assitiev_assignments += 1;
        }

        arr[j] = x;

        basic_assignments += 2;
        assitiev_assignments += 2;
    }

    auto end = chrono::high_resolution_clock::now();
    time = end - start;
}


void NaturalMergeSort(int arr[], int n, int& basic_assignments, int& assitiev_assignments,
    chrono::duration<float>& time) {

    auto start = chrono::high_resolution_clock::now();

    basic_assignments = 0;
    assitiev_assignments = 0;

    int split, last, end, i;
    int* p = arr;
    char flag = 0, sorted = 0;
    int pos1, pos2, pos3;
    int *tmp = new int[n];

    do
    {
        end = n; pos2 = pos3 = 0;
        do
        {
            p += pos2; end = n - pos3;
            for (split = 1; split < end && p[split - 1] <= p[split]; split++);

            if (split == n)
            { 
                sorted = 1;
                assitiev_assignments += 1;
                break;
            }
            pos1 = 0; pos2 = split;

            while (pos1 < split && pos2 < end)
            {
                if (p[pos1] < p[pos2])
                {
                    tmp[pos3++] = p[pos1++];
                    basic_assignments += 1;
                }
                    
                else
                {
                    tmp[pos3++] = p[pos2++];
                    basic_assignments += 1;

                    if (p[pos2] < p[pos2 - 1])
                        break;
                }
            }
        
            while (pos2 < end && tmp[pos3 - 1] <= p[pos2])
            {
                tmp[pos3++] = p[pos2++];
                basic_assignments += 1;
            }

            while (pos1 < split)
            {
                tmp[pos3++] = p[pos1++];
                basic_assignments += 1;
            }

            assitiev_assignments += 4;

        } while (pos3 < n);

        if (sorted)
            break;

        p = tmp;
        tmp = arr;
        arr = p;
        flag = !flag;

        basic_assignments += 3;
        assitiev_assignments += 4;

    } while (split < n);

    if (flag)
    {
        for (pos1 = 0; pos1 < n; pos1++)
        {
            tmp[pos1] = arr[pos1];

            basic_assignments += 1;
            assitiev_assignments += 1;
        }

        delete [] p;
    }
    else
        delete [] tmp;

    basic_assignments += 1;
    assitiev_assignments += 3;

    auto _end = chrono::high_resolution_clock::now();
    time = _end - start;
}


void ShellSort(int arr[], int n, int& basic_assignments, int& assitiev_assignments,
    chrono::duration<float>& time) {

    auto start = chrono::high_resolution_clock::now();

    basic_assignments = 0;
    assitiev_assignments = 0;

    const int t = log(n) / log(2) - 1;
    int i, j, k, m, x;

    int* h = new int[t];
    h[t - 1] = 1;

    for (m = t - 2; m >= 0; m--)
    {
        h[m - 1] = h[m + 1] * 2 + 1;
        assitiev_assignments += 2;
    }

    for (m = 0; m < t; m++) 
    {
        k = h[m];
        for (i = k; i < n; i++)
        {
            x = arr[i];
            j = i - k;

            while (j >= 0 && x < arr[j])
            {
                arr[j + k] = arr[j];
                j -= k;

                basic_assignments += 1;
                assitiev_assignments += 1;
            }

            arr[j + k] = x;

            basic_assignments += 2;
            assitiev_assignments += 2;
        }

        assitiev_assignments += 2;
    }

    delete [] h;

    assitiev_assignments += 3;

    auto end = chrono::high_resolution_clock::now();
    time = end - start;
}


void main(){

}