Не получается вывести корректные сравнения для сортировок Шелла и вставкой, почему-то они равны 0

#include <iostream>
using namespace std;
 
int bubbleSortEqu = 0;
int bubbleSortSwaps = 0;
int selectSortEqu = 0;
int selectSortSwaps = 0;
int insertSortEqu = 0;
int insertSortSwaps = 0;
int shellSortEqu = 0;
int shellSortSwaps = 0;
int quickSortEqu = 0;
int quickSortSwaps = 0;
 
int* getRowMatrix(int** matrix, int N) {
    int* rowMatrix = new int[N * N];
    int copyCount = 0;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            rowMatrix[copyCount] = matrix[i][j];
            copyCount++;
        }
    }
    return rowMatrix;
}
 
void fillMatrix(int** matrix, int* rowMatrix, int N) {
    int i = 0;
    int j = 0;
    int count = 0;
    while (count < N * N) {
        matrix[i][j] = rowMatrix[count];
        if (i <= j + 1 && i + j < N - 1)
            ++j;
        else if (i < j && i + j >= N - 1)
            ++i;
        else if (i >= j && i + j > N - 1)
            --j;
        else
            --i;
        ++count;
    }
}
 
void printMatrix(int** matrix, int N) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            cout << matrix[i][j] << " ";
        }
        cout << endl;
    }
}
 
void bubbleSort(int **matrix, int N) {
    int* rowMatrix = getRowMatrix(matrix, N);
 
    // НАЧАЛО ПУЗЫРЬКОВОЙ СОРТИРОВКИ // 
    for (int i = 0; i < N*N; i++) {
        for (int j = 0; j < N*N - 1; j++) {
            if (rowMatrix[j] > rowMatrix[j + 1]) {
                int b = rowMatrix[j];
                rowMatrix[j] = rowMatrix[j + 1];
                rowMatrix[j + 1] = b;
                bubbleSortSwaps += 3;
            }
            bubbleSortEqu++;
        }
    }
    // кОНЕЦ СОРТИРОВКИ // 
 
    int** copyMatrix;
    copyMatrix = new int*[N];
    for (int i = 0; i < N; i++) {
        copyMatrix[i] = new int[N];
    }
    fillMatrix(copyMatrix, rowMatrix, N);
    printMatrix(copyMatrix, N);
}
 
void selectSort(int** matrix, int N) {
 
    int* rowMatrix = getRowMatrix(matrix, N);
 
    // НАЧАЛО СОРТИРОВКИ ВЫБОРОМ // 
    int count, key;
    int i, j;
    for (i = 0; i < N*N - 1; i++)
    {
        count = rowMatrix[i]; key = i;
        for (j = i + 1; j < N * N; j++) {
            if (rowMatrix[j] < rowMatrix[key]) key = j;
            selectSortEqu++;
        }
 
        if (key != i)
        {
            rowMatrix[i] = rowMatrix[key];
            rowMatrix[key] = count;
            selectSortSwaps += 1;
        }
        selectSortEqu++;
    }
    // КОНЕЦ СОРТИРОВКИ
 
    int** copyMatrix;
    copyMatrix = new int*[N];
    for (int i = 0; i < N; i++) {
        copyMatrix[i] = new int[N];
    }
    fillMatrix(copyMatrix, rowMatrix, N);
    printMatrix(copyMatrix, N);
}
 
void insertSort(int** matrix, int N) {
 
    int* rowMatrix = getRowMatrix(matrix, N);
 
    // НАЧАЛО СОРТИРОВКИ ВСТАВКОЙ // 
    int buff = 0;
    int i, j;
    for (i = 1; i < N*N; i++)
    {
        buff = rowMatrix[i];
        for (j = i - 1; ((j >= 0) && (rowMatrix[j] > buff)); j--) {
            rowMatrix[j + 1] = rowMatrix[j];
            insertSortSwaps++;
        }
        rowMatrix[j + 1] = buff;
        insertSortSwaps++;
    }
    // КОНЕЦ СОРТИРОВКИ
 
    int** copyMatrix;
    copyMatrix = new int*[N];
    for (int i = 0; i < N; i++) {
        copyMatrix[i] = new int[N];
    }
    fillMatrix(copyMatrix, rowMatrix, N);
    printMatrix(copyMatrix, N);
}
 
void shellSort(int** matrix, int N) {
 
    int* rowMatrix = getRowMatrix(matrix, N);
 
    // НАЧАЛО СОРТИРОВКИ ШЕЛЛА
    int i, j, n, d, count;
    d = N * N;
    d = d / 2;
    while (d > 0)
    {
        for (i = 0; i < (N*N) - d; i++)
        {
            j = i;
            while (j >= 0 && rowMatrix[j] > rowMatrix[j + d])
            {
                count = rowMatrix[j];
                rowMatrix[j] = rowMatrix[j + d];
                rowMatrix[j + d] = count;
                shellSortSwaps += 3;
                j--;
            }
        }
        d = d / 2;
    }
    // КОНЕЦ СОРТИРОВКИ
 
    int** copyMatrix;
    copyMatrix = new int*[N];
    for (int i = 0; i < N; i++) {
        copyMatrix[i] = new int[N];
    }
    fillMatrix(copyMatrix, rowMatrix, N);
    printMatrix(copyMatrix, N);
}
 
void qsortRecursive(int* array, int size) {
    int i = 0;
    int j = size - 1;
    int mid = array[size / 2];
 
    //Делим массив
    do {
        while (array[i] < mid) {
            i++;
        }
        while (array[j] > mid) {
            j--;
        }
 
        if (i <= j) {
            int tmp = array[i];
            array[i] = array[j];
            array[j] = tmp;
            quickSortSwaps += 3;
            i++;
            j--;
        }
        quickSortEqu++;
    } while (i <= j);
 
    if (j > 0) {
        qsortRecursive(array, j + 1);
    }
    if (i < size) {
        qsortRecursive(&array[i], size - i);
    }
}
 
void quickSort(int** matrix, int N) {
 
    int* rowMatrix = getRowMatrix(matrix, N);
 
    // НАЧАЛО БЫСТРОЙ СОРТИРОВКИ  // 
    qsortRecursive(&rowMatrix[0], N*N);
    // КОНЕЦ СОРТИРОВКИ
 
    int** copyMatrix;
    copyMatrix = new int*[N];
    for (int i = 0; i < N; i++) {
        copyMatrix[i] = new int[N];
    }
    fillMatrix(copyMatrix, rowMatrix, N);
    printMatrix(copyMatrix, N);
}
 
bool checkCorrect(int** matrix, int N) {
    int firstElem = matrix[0][0];
    for (int i = 0; i < N; i++) {
        for (int j = 1; j < N; j++) {
            if (matrix[i][j] != firstElem) {
                return true;
            }
        }
    }
    return false;
}
 
int main()
{
 
    int N;
    cout << "Enter N:" << endl;
    while (true) {
        cin >> N;
        if (cin.fail() || N <= 0) {
            cin.clear();
            cout << "Input error" << endl;
            cin.ignore(100, '\n');
        }
        else {
            break;
        }
    }
 
    int **matrix;
    matrix = new int*[N];
    for (int i = 0; i < N; i++) {
        matrix[i] = new int[N];
    }
 
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            matrix[i][j] = rand() % 100 + 1;
        }
    }
 
    if (checkCorrect(matrix, N)) {
        cout << "Matrix:" << endl;
        printMatrix(matrix, N);
        cout << "Bubble sort:" << endl;
        bubbleSort(matrix, N);
        cout << "Select sort:" << endl;
        selectSort(matrix, N);
        cout << "Insert sort:" << endl;
        insertSort(matrix, N);
        cout << "Shell sort:" << endl;
        shellSort(matrix, N);
        cout << "Quick sort:" << endl;
        quickSort(matrix, N);
 
        cout << "Bubble sort | Select sort | Insert sort | Shell sort | Quick sort" << endl;
        cout << "Equ = " << bubbleSortEqu << ", Swaps = " << bubbleSortSwaps << " | ";
        cout << "Equ = " << selectSortEqu << ", Swaps = " << selectSortSwaps << " | ";
        cout << "Equ =" << insertSortEqu << ", Swaps = " << insertSortSwaps << " | ";
        cout << "Equ = " << shellSortEqu << ", Swaps = " << shellSortSwaps << " | ";
        cout << "Equ = " << quickSortEqu << ", Swaps = " << quickSortSwaps << " | ";
    }
    else {
        cout << "Error! Matrix incorrect" << endl;
    }
 
 
 
}