malloc：釋放的 object 的校驗和不正確

Question

下面是 function 做歸並排序。 但我在執行時遇到錯誤。 function merge每次都釋放分配的內存（aux），為什么釋放后會被修改？

 a.out(65287,0x1112bedc0) malloc: Incorrect checksum for freed object 0x7ff9a4c05888: probably modified after being freed. Corrupt value: 0xb00000003 a.out(65287,0x1112bedc0) malloc: *** set a breakpoint in malloc_error_break to debug Abort trap: 6

void merge(int arr[], int lo, int mid, int hi) {
    int i = lo; 
    int j = mid + 1;
    int *aux = (int *)malloc((hi - lo + 1) * sizeof(int));
    for (int k = lo; k <= hi; k++) {
        aux[k] = arr[k];
    }   
    for (int k = lo; k <= hi; k++) {
        if (i > mid)
            arr[k] = aux[j++];
        else if (j > hi)
            arr[k] = aux[i++];
        else if (aux[i] > aux[j])
            arr[k] = aux[j++];
        else
            arr[k] = aux[i++];
    } 
    free(aux);
}

void mergesort1(int arr[], int lo, int hi) {
    if (lo >= hi)
        return;
    int mid = lo + (hi - lo) / 2;
    mergesort1(arr, lo, mid);
    mergesort1(arr, mid + 1, hi);
    merge(arr, lo, mid, hi);
}

致電：

mergesort1(arr, 0, 9);

Answer 1

malloc((hi - lo + 1) * sizeof(int))為索引從 0 到hi-lo的元素分配空間，但是for (int k = lo; k <= hi; k++) … aux[k] = …訪問索引從lo到hi的元素，因此寫入分配的 memory 之外。

Answer 2

aux數組未正確初始化： for (int k = lo; k <= hi; k++) { aux[k] = arr[k]; } for (int k = lo; k <= hi; k++) { aux[k] = arr[k]; }應該是：

    for (int k = lo; k <= hi; k++) {
        aux[k -lo] = arr[k];
    }

您的代碼寫入超出分配數組的末尾，可能導致malloc()和free()用於跟蹤分配的 memory 的數據損壞。

請注意， i和j也應該以不同的方式初始化，並且在合並排序算法中包含上限會令人困惑。 如果排除hi ，則代碼更簡單，因為不需要+1 / -1調整：

void merge1(int arr[], int lo, int mid, int hi) {
    int i = 0; 
    int j = mid -= lo;
    int n = hi - lo;
    int *aux = (int *)malloc(n * sizeof(int));
    for (int k = 0; k < n; k++) {
        aux[k] = arr[lo + k];
    }   
    for (int k = lo; k < hi; k++) {
        if (i >= mid)
            arr[k] = aux[j++];
        else if (j >= n)
            arr[k] = aux[i++];
        else if (aux[i] > aux[j])
            arr[k] = aux[j++];
        else
            arr[k] = aux[i++];
    } 
    free(aux);
}

void mergesort1(int arr[], int lo, int hi) {
    if (hi - lo < 2)
        return;
    int mid = lo + (hi - lo) / 2;
    mergesort1(arr, lo, mid);
    mergesort1(arr, mid, hi);
    merge1(arr, lo, mid, hi);
}

調用： mergesort1(arr, 0, 10); ，這更簡單，因為 10 是數組長度。

使用指針算法可以進一步簡化代碼：

void merge2(int arr[], int mid, int hi) {
    int *aux = malloc(n * sizeof(*aux));
    for (int i = 0; i < n; i++) {
        aux[i] = arr[i];
    }   
    for (int i = 0, j = mid, k = 0; i < mid;) {
        if (j >= n || aux[i] <= aux[j])
            arr[k++] = aux[i++];
        else
            arr[k++] = aux[j++];
    } 
    free(aux);
}

void mergesort2(int arr[], int n) {
    if (n < 2)
        return;
    int mid = n / 2;
    mergesort2(arr, mid);
    mergesort2(arr + mid, n - mid);
    merge2(arr, mid, n);
}

調用： mergesort2(arr, 10); ，其中 10 是數組長度。