Question

我正在尝试使用通用的heapsort。它与字符串完美配合，但由于某种原因不适用于整数类型。完全失去了为什么会这样。我确信比较功能是正确的。 heapsort函数中的最后一个if语句用于纠正有时会导致第0个和第1个索引反转的错误。

#include "heapsort.h"                                                          
#include <stdio.h>                                                             
#include <assert.h>                                                            
#include <string.h>                                                            
#include <stdlib.h>                                                            
#include <ctype.h>                                                             
#include <sys/types.h>                                                         

int heapsort(void *base, size_t nel, size_t width, int (*compar)(const void *, const void *)) 
{                                                                              
    int i;                                                                     
    int j;                                                                     

    printf("\n");                                                              
    /*build heap*/                                                             

    for (j = 1; j < nel; j++) {                                                
        i = j;                                                                 
        while (compar(base + i * width, base + (i-1)/2 * width) > 0) {         
            swap(base + i * width, base + (i-1)/2 * width);                    
            i = (i-1)/2;-                                                      
        }                                                                      
    }                                                                          

    /*sort*/                                                                   

    for (i = 1; i < nel; i++) {                                                
        swap(base , base + (nel - i) * width);                                 
        j = 0;                                                                 

        while (((2 * j + 1) < nel - i) && ((2 * j + 2) < nel - i)){            
            if (compar(base + (j * 2 + 2) * width, base + (j * 2 + 1) * width) > 0 
            &&  compar(base + j * width, base + (j * 2 + 2) * width) < 0)      
            {                                                                  
                swap(base + j * width, base + (2 * j + 2) * width);            
                j = 2 * j + 2;                                                 
            }                                                                  
            else if (compar(base + (j * 2 + 2) * width, base + (j * 2 + 1) * width) <= 0 
                  && compar(base + j * width, base + (j * 2 + 1) * width) < 0) 
            {                                                                  
                swap(base + j * width, base + (2 * j + 1) * width);            
                j = 2 * j + 1;                                                 
            }                                                                  
            else                                                               
                break;                                                         
        }                                                                      

    }                                                                          

    if (compar(base + 0 * width, base + 1 * width) > 0) {                      
        swap(base + 0 * width, base + 1 * width);                              
    }                                                                          

    return 0;                                                                  
}                                                                              


void swap(void *a, void *b)                                                    
{                                                                              
    void *temp;                                                                
    printf("swapping %d and %d\n", *(int*)a, *(int*)b);                        
    temp = *(void**)a;                                                         
    *(void**)a = *(void**)b;                                                   
    *(void**)b = temp;                                                         
}

int intcmp(const void * a, const void * b)
{
    return *(int*)a - *(int*)b;
}

Answer 1

swap函数看起来不对。假设a和b引用的值是指针（如果类型为[const] char *字符串将起作用）并且交换sizeof(void *)字节。可能是您系统上的sizeof(int) != sizeof(void *)。

您需要交换width个字节。

Heapsort使用字符串而不是整数

1 个答案: