两种排序算法在同一数组上为我提供了两个不同的输出（quickSort和heapSort）！

Question

I don't understand why they give me different output when I compile them. For example ... when I compile only one algorithm the answer is good, the same is for the other one, but when I compile them both at the same time they give me some weird output.

My code:

#include <iostream>
using namespace std;


int parent(int i){
    return i/2;
}
int leftChild(int i){
    return 2*i+1;
}
int rightChild(int i){
    return 2*i+2;
}
void maxHeapify(int a[], int i, int n){
    int largest;
    int temp;
    int l = leftChild(i);
    int r = rightChild(i);
    //   p.countOperation("CMPbottomUp",n);
    if (l <= n && (a[l] > a[i]))
        largest = l;
    else
        largest = i;
    //      p.countOperation("CMPbottomUp",n);
    if (r <= n && (a[r] > a[largest]))
        largest = r;
    if (largest != i){
        //    p.countOperation("ATTbottomUp",n);
        temp = a[i];
        //  p.countOperation("ATTbottomUp",n);
        a[i] = a[largest];
        //p.countOperation("ATTbottomUp",n);
        a[largest] = temp;
        maxHeapify(a, largest, n);
    }
}

void buildMaxHeap(int a[], int n){
    for (int i=n/2; i>=0; i--){
        maxHeapify(a, i, n);
    }
}
void heapSort(int a[],int n){
    buildMaxHeap(a,n);
    int n1=n;
    int temp;
    for(int i=n1;i>0;i--){
        temp = a[0];
        a[0] = a[i];
        a[i] = temp;
        n1--;
        maxHeapify(a,0,n1);
    }

}

int partitionArray(int arr[], int left, int right){
    int i = left, j = right;
    int tmp;
    int pivot = arr[(left + right) / 2];
    while (i <= j) {
        while (arr[i] < pivot)
            i++;
        while (arr[j] > pivot)
            j--;
        if (i <= j) {
            tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
            i++;
            j--;
        }
    }
    return i;
}

void quickSort(int arr[], int left, int right) {
    int index;
    index = partitionArray(arr, left, right);
    if (left < index - 1)
        quickSort(arr, left, index - 1);
    if (index < right)
        quickSort(arr, index, right);
}

int main(){
    int x[8]= {5,87,21,4,12,7,44,3};
    int a[8];
    for(int i=0;i<8;i++){
        a[i] = x[i];
    }
    heapSort(x,8);
    quickSort(a,0,8);

    for(int i=0;i<8;i++){
        cout<<a[i]<<' ';
    }
    cout<<endl;

    for(int j=0;j<8;j++){
        cout<<x[j]<<' ';
    }

    return 0;
}

Example output:

1) When I compile only one algorithm the output is : 3,4,5,7,12,21,44,87 (which is good)

2) When I compile both of them in the code the output is: 87,4,5,7,12,21,44,87 (quickSort) and 3,3,4,5,7,12,21,44 (heapSort)

Answer 1

Arrays a and x are right next to each others in stack. Seeing how you have duplicate value 87 in output, it seems your sort functions access memory outside the array you give to them. This is buffer overrun, a type of Undefined Behaviour. With that, your code could do anything because you have corrupted variable values (or worse, corrupted addresses/pointers).

Double check how you access arrays. Remember that C array indexes for your arrays of length 8 are 0..7!

Answer 2

I think that should work:

heapSort(x,7);
quickSort(a,0,7);