Good evening. It’s been a few days since I’ve been able to convert this algorithm to sort a three-dimensional array. It should sort P two-dimensional matrices by columns “through” the whole array, not each column separately. The whole program code would not fit here, so I attach a small demo version. The algorithm for the vector is working, there are no errors in it. Can anyone help me? I sincerely do not understand what can be the error. Thank you for your time.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

clock_t Select8_3D(int*** A, int P, int M, int N) {
    int Li, Ri, Lj, Rj, imin, imax, jmin, jmax, temp;

    clock_t time_start, time_stop;
    time_start = clock();

    for (int k = 0; k < P; k++) {

        Lj = 0;
        Rj = N - 1;

        while (Lj < Rj) {

            jmin = Lj;
            jmax = Lj;

            Li = 0;
            Ri = M - 1;

            while (Li < M) {
                imin = Li;
                imax = Li;

                // search for minimum and maximum for the leftmost column 
                for (int i = Li + 1; i < M; i++) {
                    if (A[k][i][jmin] < A[k][imin][jmin]) {
                        imin = i;
                    }
                    else if (A[k][i][jmin] > A[k][imax][jmin]) {
                        imax = i;
                    }
                }

                // search for minimum and maximum for rectangular area
                for (int j = Lj + 1; j < Rj; j++) {
                    for (int i = 0; i < M; i++) {
                        if (A[k][i][j] < A[k][imin][jmin]) {
                            imin = i;
                            jmin = j;
                        }
                        else if (A[k][i][j] > A[k][imax][jmax]) {
                            imax = i;
                            jmax = j;
                        }
                    }
                }


                // search for minimum and maximum for the rightmost column 
                for (int i = 0; i <= Ri; i++) {
                    if (A[k][i][Rj] < A[k][imin][jmin]) {
                        imin = i;
                        jmin = Rj;
                    }
                    else if (A[k][i][Rj] > A[k][imax][jmax]) {
                        imax = i;
                        jmax = Rj;
                    }
                }

                // repositioning of elements
                if (imin != Li && jmin != Lj) {
                    temp = A[k][imin][jmin];
                    A[k][imin][jmin] = A[k][Li][Lj];
                    A[k][Li][Lj] = temp;
                }

                if (imax != Ri && jmax != Rj) {
                    if (imax == Li && jmax == Lj) {
                        temp = A[k][imin][jmin];
                        A[k][imin][jmin] = A[k][Ri][Rj];
                        A[k][Ri][Rj] = temp;
                    }
                    else {
                        temp = A[k][imax][jmax];
                        A[k][imax][jmax] = A[k][Ri][Rj];
                        A[k][Ri][Rj] = temp;
                    }
                }

                Li += 1;
                Ri -= 1;
            }
            Lj += 1;
            Rj -= 1;
        }

    }

    time_stop = clock();
    return (time_stop - time_start);
}


void printMatrix(int*** A, int P, int M, int N) {
    for (int k = 0; k < P; ++k) {
        printf("matrix %d:n", k + 1);
        for (int i = 0; i < M; ++i) {
            for (int j = 0; j < N; ++j) {
                printf("%d ", A[k][i][j]);
            }
            printf("n");
        }
        printf("n");
    }
}

int main() {
    int P = 2; // number of “matrices”
    int M = 10; // number of lines
    int N = 10; // number of columns

    // Memory allocation and matrix initialization
    int*** A = (int***)malloc(P * sizeof(int**));
    for (int i = 0; i < P; ++i) {
        A[i] = (int**)malloc(M * sizeof(int*));
        for (int j = 0; j < M; ++j) {
            A[i][j] = (int*)malloc(N * sizeof(int));
            for (int k = 0; k < N; ++k) {
                A[i][j][k] = rand() % 100; // случайные значения
            }
        }
    }

    // Output of initial matrices
    printf("Matrix before sorting:n");
    printMatrix(A, P, M, N);

    // Algorithm call
    clock_t execution_time = Select8_3D(A, P, M, N);


    // Output of sorted matrices
    printf("nSorted matrix:n");
    printMatrix(A, P, M, N);

    // Memory release
    for (int i = 0; i < P; ++i) {
        for (int j = 0; j < M; ++j) {
            free(A[i][j]);
        }
        free(A[i]);
    }
    free(A);

    return 0;
}

The way it works in my program:

Algorithm for vector:

clock_t Select8_1D(int* A, int N, int P) {
    int L, R, imin, imax, tmp;

    clock_t time_start, time_stop;
    time_start = clock();

    L = 0; R = N - 1;

    while (L < R) {
        imin = L; imax = L;

        for (int i = L + 1; i < R + 1; i++) {
            if (A[i] < A[imin]) {
                imin = i;
            }
            else if (A[i] > A[imax]) {
                imax = i;
            }
        }

        if (imin != L) {
            tmp = A[imin];
            A[imin] = A[L];
            A[L] = tmp;
        }

        if (imax != R) {
            if (imax == L) {
                tmp = A[imin];
                A[imin] = A[R];
                A[R] = tmp;
            }
            else {
                tmp = A[imax];
                A[imax] = A[R];
                A[R] = tmp;
            }
        }

        L = L + 1;
        R = R - 1;
    }
    time_stop = clock();
    return (time_stop - time_start) * P;
}

The way it works in my program:

Described above, but I’m just out of ideas already. I’m hoping for your help.