Question

我目前发现了一个有趣且简单的排序算法，因此我使用动态分配的数组实现了它。这是我的代码。

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

void positiveIntSort(int *array,int size);
void printArray(int array[],int size);

int main() {
    int bigNum = 99999;
    int *array = (int *) malloc (bigNum*sizeof(int));
    int i,index,size;
    printf("Enter the size of array: ");
    scanf("%d",&size);
    printf("Enter each element for array: ");
    for(i = 0; i < size; i++) {
        scanf("%d",&index);
        array[index] = 1;
    }
    positiveIntSort(array,size);
    printArray(array,size);
}

int positiveIntSort(int *array,int size) {
    int i,j = 0;
    int sortedArray[size];
    for(i = 0; i < 99999,j < size; i++) {
        if(array[i] == 1)
            sortedArray[j++] = i;
    }
    memcpy(array,sortedArray,size);
    printArray(sortedArray,size);
}

void printArray(int array[],int size) {
    int i;
    for(i = 0; i < size; i++) {
        printf("%d\t",array[i]);
    }
    printf("\n");
}

所以，基本上我正在做的是如果用户输入一个数字：a，我转到相应的索引，在这种情况下为a，并将1分配给此array[a] 。所以我再次遍历并使用值1打印所有索引。这种方式给了我一个排序数组。

但是，我对动态分配的数组有些麻烦。这是我的示例输出：

Enter the size of array: 5
Enter each element for array:23 12 45 63 38
12       23      38      45     63
12       1845015 0       0      0

所以排序绝对有效。但是，当我将已排序的数组返回到动态分配的数组时，结果搞砸了。我找不到原因？我使用memcpy的方式不正确吗？

此外，该算法的复杂性为O（n）。反正有没有让这个算法更好？

Answer 1

您的问题是size memcpy()调用positiveIntSort内的memcpy(array,sortedArray,size*sizeof(int));个参数它应该是：

memcpy()

因为positiveIntSort()需要第三个参数来复制的字节数（而不是数组元素的数量）。

另请注意，您的void类型存在冲突，其中一个返回int而另一个array，实施也会忽略这些类型。

现在关于改进算法：

您的阵列不需要任意大小。（或者：任意最大值）。将用户输入存储在临时数组中，并查找最大值和最小值。然后在d中为（max-min + 1）个整数分配空间。对于每个值d-min，将其插入数组的calloc()位置。你需要一个额外的循环，但时间复杂度仍然是O（n）（*），不仅你没有不必要的约束，而且你可以减少内存开销。
重复输入值怎么样？现在你的算法无法处理重复。您可以将 1添加到初始数组的相应单元格中，而不是将每个数字的设置为 1。这样，如果你在排序功能上付出额外的努力，你可以正确地找到并排序所有重复项。
负面价值怎么样？一种方法是执行两种不同的排序（一种用于底片，一种用于底片）并在最后连接它们（如果你这样做就更好）。

最后，正如评论中提到的那样，你还需要在数组中初始化你的值，因为有些可能是1（使用M where 5<min flip M来让你的生活更轻松）。

（*）：确切地说，您的复杂度现在为Θ（max {n，nmax-nmin}），其中nmax和nmin是输入的最大值和最小值。（或者数组的大小，因为你将遍历它）

Answer 2

但是，我对动态分配的数组有些麻烦。

在您的代码中，您已为阵列分配了空间：

   int *array = (int *) malloc (bigNum*sizeof(int));

正是这么多字节：bigNum * sizeof(int)。

（顺便说一句：没有必要在C语言中投射malloc的结果。建议检查分配是否成功，NULL的非malloc结果是返回。）

您可以在获取数组大小后声明它，而不是动态分配array（您忘记了free array内存）：

   //int *array = (int *) malloc (bigNum*sizeof(int));
   int i,index,size,bigNum;
   printf("Enter the size of array: ");
   scanf("%d",&bigNum );
   int array[bigNum];
   printf("Enter the number of elements: ");
   scanf("%d",&size);

这也与未初始化的数组元素有关。

在int positiveIntSort(int *array,int size){

中对称

您必须复制属于array的所有字节。此array中的字节数等于数字或数组元素乘以元素的大小。在您的情况下，元素的大小如果等于sizeof(int)。

因此该行

   memcpy(array,sortedArray,size);

应替换为：

   memcpy(array,sortedArray,size* sizeof(int));

我不会评论你的算法的逻辑，它似乎没有处理重复和负值。

不同的排序算法具有不同的时间复杂度：

如果您需要比您更快的排序时间，您可以考虑其他算法。

内存复制动态分配的数组

2 个答案: