三维数组全局按列排序算法改写求助：效果不符排查

我将运行正常的一维排序算法Select8_1D改写为适用于三维数组的Select8_3D算法，期望实现对P个二维矩阵的全局按列排序（非单列独立排序），但实际运行效果与预期不符，恳请协助排查问题。

三维算法代码 #

#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;
}

效果对比 #

• 实际效果：
• 期望效果：

一维算法代码（运行正常） #

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;
}

一维算法运行效果 #

我已尝试排查但毫无头绪，恳请协助找出三维算法中的错误。

内容的提问来源于stack exchange，提问作者apromise