尝试释放malloc时出错

因此，我从学校得到的任务是编写一个函数，该函数获取一个int

size

参数、一个整数数组和一个int

标志

，并返回一个指针数组，该数组以排序方式保存指向原始int数组单元格的指针（如果标志=1，则升序，否则降序）

我基本上是根据合并排序的原理编写的，但是由于某种原因，当程序试图执行第123行时，我得到了一个错误（释放一个临时int**数组） 知道它为什么会发生，以及它是否可以修复吗

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>

#define SIZE 100

int **pointerSort(int *arr, unsigned int size, int ascend_flag);
void ptrMerge(int arr[], int start, int mid, int end, int *ptrArr[], int flag);
void pmergeSort(int arr[], int start, int end, int *ptrArr[], int flag);

void main() {
    unsigned int size, i;
    int arr[SIZE];
    int **pointers;
    int ascend_flag;

    printf("Please enter the number of items:\n");
    scanf("%u", &size);

    for (i = 0; i < size; i++)
        scanf("%d", &arr[i]);

    scanf("%d", &ascend_flag);

    pointers = pointerSort(arr, size, ascend_flag);

    printf("The sorted array:\n"); //Print the sorted array

    //printPointers(pointers, size);
    for (i = 0; i < size; i++)
        printf("d%\t%d", *pointers[i], pointers[i]);

    free(pointers);
}

int **pointerSort(int *arr, unsigned int size, int ascend_flag) {
    int **sortedArr;

    sortedArr = (int**)malloc(size * sizeof(int*));
    pmergeSort(arr, 0, size - 1, sortedArr, ascend_flag);

    return sortedArr;
}

void pmergeSort(int arr[], int start, int end, int *ptrArr[], int flag) {

    if (start < end) {
        int mid = (start + end) / 2;

        pmergeSort(arr, start, mid, ptrArr, flag);
        pmergeSort(arr, mid + 1, end, ptrArr, flag);

        ptrMerge(arr, start, mid, end, ptrArr, flag);
    }
}

void ptrMerge(int arr[], int start, int mid, int end, int *ptrArr[], int flag) {
    int i, k = 0;
    int p = start, q = mid + 1;
    int **tempArr;

    tempArr = (int**)malloc((end - start + 1) * sizeof(int*));

    for (i = start; i <= end; i++) {
        if (arr[p] < arr[q]) {
            tempArr[k] = &arr[p];
            k++;
            p++;
        } else { //(arr[p] > arr[q])
            tempArr[k] = &arr[q];
            k++;
            q++;
        }
    }
    while (p <= mid) {
        tempArr[k] = &arr[p];
        k++;
        p++;
    }
    while (q <= end) {
        tempArr[k] = &arr[q];
        k++;
        p++;
    }

    if (flag == 1) { 
        for (i = 0; i < k; i++) 
            ptrArr[start] = tempArr[i];
            start++;
        }
    } else {
        for (i = k - 1; i >= start; i--) {
            ptrArr[start] = tempArr[i];
            start++;
        }
    }

    for (i = 0; i < k; i++)
        printf("%x\t%d\n", ptrArr[i], *ptrArr[i]);
    printf("\n");

    free(tempArr);
}

\define\u CRT\u SECURE\u NO\u警告
#包括
#包括
#包括
#包括
#定义大小100
int**pointerSort（int*arr、无符号int大小、int递增标志）；
void ptrMerge（int arr[]，int start，int mid，int end，int*ptrArr[]，int flag）；
void pmergeSort（int arr[]，int start，int end，int*ptrArr[]，int flag）；
void main（）{
无符号整数大小，i；
int arr[尺寸]；
int**指针；
国际升旗；
printf（“请输入项目编号：\n”）；
scanf（“%u”、&size）；
对于（i=0；i
int main(void)

在这种情况下，q永远不会更新，所以我猜是无限循环

while (q <= end)
    {
        tempArr[k] = &arr[q];
        k++;
        p++;
    }

while（q您得到一个分段错误，因为
ptrMerge
函数通过写入
tempArr
分配数组的末尾来破坏内存

第一个循环迭代
end-start+1次
，可能访问片末尾以外的
arr

循环一直持续到
p>=mid
和
q>=end
，写入
tempArr[k]
，其中
k
大于或等于分配给
malloc（）
的元素数

逻辑有缺陷：您在偏移量
p
和
q
处比较
arr
的元素，而不是通过数组
ptrArr
间接进行

以下是修改后的版本：

int**pointerSort（int*arr、int-size、int-ascend\u标志）{
int**sortedar=（int**）malloc（尺寸*尺寸（int*）；
对于（int i=0；i如果（p=end | |*ptrArr[p]嘿，我试着为（i=start；i）添加这些行
    for (i = 0; i < size; i++)
        printf("%d\t", *pointers[i]);
    printf("\n");