从函数返回到main的指针数组为NULL

一旦您的函数返回，int* sortedArr[size];inint** pointerSort(int* arr, unsigned int size, char ascend_flag)就会无效，因为它是分配给堆栈的自动变量。

你需要一个永久的存储空间。例如，sortedArr通过malloc函数在堆上分配内存并返回它。

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

#define SIZE 100

// Functions declaration
int** pointerSort(int* arr, unsigned int size, char ascend_flag);
void sortMerge (int** sortedArr, int left, int right, char ascend_flag);
void mergeSortAscend (int** arr, int left, int middle, int right);
void mergeSortDescend (int** arr, int left, int middle, int right);
void copyAddress(int** addressArray, int* arr, unsigned int size);

int main(void)
{
    int** sortedArr;
    int  arr[5] = {8,1,7,2,4};
    int size = 5;
    int i =0;

    sortedArr = pointerSort(arr, size, '1');

    if(sortedArr) // memory was allocated
       for(i=0; i<5; i++){
           printf("%d ", *sortedArr[i]);
       }

    free(sortedArr);
    return 0;
}

// The pointerSort function gets an array, its size and a flag representing "sort by" (ascending, descending)
int** pointerSort(int* arr, unsigned int size, char ascend_flag)
{
    // Variables declaration
    //int* sortedArr[size];
    int ** sortedArr = malloc( sizeof(int *) * size);
    if(sortedArr == NULL) return NULL; // no memory

    // Copying the addresses of each value in arr to an addresses array
    copyAddress(sortedArr, arr, size);

    // Sending the array of addresses, its start and end and the ascend_flag to the sortMerge function
    sortMerge(sortedArr, 0, size - 1, ascend_flag);

    return (sortedArr);
}

void sortMerge (int** sortedArr, int left, int right, char ascend_flag)
{
    // Variables declaration
    int middle = (left + right) / 2;

    // Checking if there are more than one cell
    if (left < right)
    {
        // Splitting the array into two
        sortMerge(sortedArr, left, middle, ascend_flag);
        sortMerge(sortedArr, middle + 1, right, ascend_flag);

        // Checking if the sort requested is ascending or descending
        if (ascend_flag != '0')
        {
            mergeSortAscend(sortedArr, left, middle, right);
        }
        else
        {
            mergeSortDescend(sortedArr, left, middle, right);
        }
    }
}

void mergeSortAscend (int** arr, int left, int middle, int right)
{
    int l = left, m = middle + 1, r = right, i = left;
    int* temp[SIZE];

    while ((l <= middle) && (m <= right))
    {
        if (*(arr[l]) > *(arr[m]))
        {
            temp[i] = arr[m];
            m++;
        }
        else
        {
            temp[i] = arr[l];
            l++;
        }
        i++;
    }

    if (l <= middle)
    {
        while (l <= middle)
        {
            temp[i] = arr[l];
            l++;
            i++;
        }
    }

    if (m <= right)
    {
        while (m <= right)
        {
            temp[i] = arr[m];
            m++;
            i++;
        }
    }
    for (int k = left; k <= right; k++)
    {
        arr[k] = temp[k];
    }
}

void copyAddress(int** addressArray, int* arr, unsigned int size)
{
    int i;

    for (i = 0; i < size; i++)
    {
        addressArray[i] = &(arr[i]);
    }
}

void mergeSortDescend (int** arr, int left, int middle, int right)
{
    int l = left, m = middle + 1, r = right, i = left;
    int* temp[SIZE];

    while ((l <= middle) && (m <= right))
    {
        if (*(arr[l]) <= *(arr[m]))
        {
            temp[i] = arr[m];
            m++;
        }
        else
        {
            temp[i] = arr[l];
            l++;
        }
        i++;
    }

    if (l <= middle)
    {
        while (l <= middle)
        {
            temp[i] = arr[l];
            l++;
            i++;
        }
    }

    if (m <= right)
    {
        while (m <= right)
        {
            temp[i] = arr[m];
            m++;
            i++;
        }
    }

    for (int k = left; k <= right; k++)
    {
        arr[k] = temp[k];
    }
}

测试：

1 2 4 7 8