Сортировка Шелла. Написал программу, не могу понять, почему сортировка не выполняется

#include <iostream>
#include <locale>
#include <time.h>
#include <cstdlib>
#include <deque>
#include <stdlib.h>
 
using namespace std;
 
void bubble_sort(int *mass, int N)
{
    for (int i = 0; i < N - 1; i++)
    {
        for (int j = 0; j < N - i - 1; j++)
        {
            if (mass[j] > mass[j + 1])
            {
                swap(mass[j], mass[j + 1]);
            }
        }
    }
}
 
int increment(long inc[], long size)
{
    int p1, p2, p3, s;
    p1 = p2 = p3 = 1;
    s = -1;
    do
    {
        if (++s % 2)
        {
            inc[s] = 8 * p1 - 6 * p2 + 1;
        }
        else
        {
            inc[s] = 9 * p1 - 9 * p3 + 1;
            p2 *= 2;
            p3 *= 2;
        }
        p1 *= 2;
    } while (3 * inc[s] < size);
 
    return s > 0 ? --s : 0;
}
 
template< class T >
void shell_Sort(T a[], long size)
{
    long inc, i, j, seq[40];
    int s;
 
    s = increment(seq, size); // вычисление последовательности приращений
    while (s >= 0)  // сортировка вставками с инкрементами inc[] 
    {
        inc = seq[s--];
        for (i = inc; i < size; ++i)
        {
            T temp = a[i];
            for (j = i - inc; (j >= 0) && (a[j] > temp); j -= inc)
                a[j + inc] = a[j];
            a[j] = temp;
        }
    }
}
 
int main()
{
    locale::global(locale(""));
    srand((unsigned)time(NULL));
 
    int N, i;
    double A, B, X;
    int temp = 0;
    int from, to;
    char *type = new char[6];
 
    cout << "Введите размерность массива: ";
    cin >> N;
 
    cout << endl << "Введите диапазон случайных чисел: ";
    cin >> from >> to;
 
    int *mass = new int[N];
 
    cout << endl << "Полученный массив:" << endl;
 
    for (i = 0; i < N; i++)
    {
        mass[i] = rand() % (to - from + 1) + from;;
        cout << mass[i] << " ";
 
        temp = temp + mass[i];
    }
 
    cout << endl<< "bubble или shell?" << endl;
    cin >> type;
 
    while (strcmp(type, "Bubble") != 0 && strcmp(type, "bubble") != 0 && strcmp(type, "Shell") != 0 && strcmp(type, "shell") != 0)
    {
        cout << "Попробуте еще раз.";
        cin >> type;
    }
 
    if (strcmp(type, "Bubble") == 0 || strcmp(type, "bubble") == 0)
        bubble_sort(mass, N);
    else
        shell_Sort(mass, N);
 
    system("pause");
 
    return 0;
}

template< typename RandomAccessIterator, typename Compare >
void shell_sort( RandomAccessIterator first, RandomAccessIterator last, Compare comp )
{
    for( typename std::iterator_traits< RandomAccessIterator >::difference_type d = ( last - first ) / 2; d != 0; d /= 2 )
        for( RandomAccessIterator i = first + d; i != last; ++i )
            for( RandomAccessIterator j = i; j - first >= d && comp( *j, *( j - d ) ); j -= d )
                std::swap( *j, *( j - d ) );
}

#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <time.h>
using namespace std;
 
// Ввод параметров
void input_params(int&, int&, int&);
// Создание массива
int* create_array(const int, const int, const int);
// Вывод массива
void print_array(int*, const int);
// Выбор метода сортировки
int menu_sort();
// Сортировка
void bubble_sort(int*, const int);
void shell_sort(int*, const int);
 
// Массив из указателей на функцию
void (*sort [2]) (int*, const int) = {bubble_sort, shell_sort};
 
 
int main()
{
    int size, low, high;
    input_params(size, low, high);
    
    int *arr = create_array(size, low, high); 
    
    print_array(arr, size);
    
    // Выбор метода сортировки массива
    (*sort[menu_sort()])(arr, size);
 
    print_array(arr, size);
    
    // Удаление динамического массива
    delete [] arr;
    
    return 0;
}
 
void input_params(int &size, int &low, int &high)
{
    cout << "Size of array: ";  cin >> size;    
    cout << "Low border: ";     cin >> low;     
    cout << "High border: ";    cin >> high;    
}
 
 
int* create_array(const int size, const int low, const int high)
{
    srand(time(NULL));                          // для истинной рандомизации
    int *arr = new int[size];
    for(int i = 0; i < size; ++i)
        arr[i] = low + rand() % (high - low + 1);  // рандомизация в пределах  
    return arr;
}
 
void print_array(int *arr, const int size)
{
    cout << "ARRAY:";
    for(int i = 0; i < size; ++i)
    {
        if (i % 10 == 0)  cout << '\n'; // в строке печатать не более 10 значений
        cout << arr[i] << '\t';         // значения разделять табуляцией
    }
    cout << '\n';
}
 
int menu_sort()
{
    char ch;
    do 
    {
        cout << "1. Bubble sort\n";
        cout << "2. Shell sort\n";
        cout << "Select a number: ";
 
        cin >> ch;
 
    } 
    while(!strchr("12", ch));
    return ch-49;               // преобразование к целочисленному эквиваленту
}
 
void bubble_sort(int *arr, const int size)
{
    for (int i = size - 1; i >= 0; i--)
        for (int j = 0; j < i; j++)
            if (arr[j] > arr[j+1]) swap(arr[j], arr[j + 1]);
}
 
// Идея метода заключается в сравнение разделенных на группы элементов
// находящихся друг от друга на некотором расстоянии d
// Изначально это расстояние равно d = size div 2 (тоже самое d = d >> 1)
// На первом шаге из каждой группы сравниваются два элемента расположенных друг от друга на расстоянии d;
// В случае необходимости, меняются местами.
// На последующих шагах также происходят проверка и обмен, но расстояние d сокращается на 2.
void shell_sort(int *arr, const int size)
{
    int d = size >> 1;
    while (d > 0)
    {
        for (int i = 0; i < (size - d); i++)
        {
            int j = i;
            while (j >= 0 && arr[j] > arr[j + d])
            {
                swap(arr[j], arr[j + d]);
                j--;
            }
        }
        d = d >> 1;
    } 
};