C O表示法并合并两个已排序的数组

我被告知将两个已经排序的数组，大小不同，A和B合并成一个数组，C在线性时间内

通过线性时间，我知道这个算法的时间复杂度必须是开的。后来，我还被告知在合并数组时执行排序

我的一个想法是创建一个算法，在两个数组中都有两个指针，指向最小的元素。指向的最小元素将进入新数组。当一个数组耗尽时，另一个数组的其余元素将复制到新数组中

由于我几个月前才开始编程，我发现这很难实现，因此我决定执行Merge-Sort-MS，因为它与上述算法最为相似。然而，我关心的是MS本身的时间复杂性-Onlogn

然而，考虑到这两个数组已经被排序，MS的时间复杂度会降低还是保持不变

---

提前感谢。

您的任务是实现mergesort算法的合并阶段。mergesort对数据集进行排序的复杂度为ON.logN，但每个合并阶段所需的线性时间与合并集的长度成正比

下面是用于此的伪代码：

merge(array a, array b into array c)
    int i = 0, j = 0, k = 0;
    while (i < len(a) and j < len(b)) {
        if (a[i] <= b[j]) {
            c[k++] = a[i++];
        } else {
            c[k++] = b[j++];
        }
    }
    while (i < len(a)) {
        c[k++] = a[i++];
    }
    while (j < len(b)) {
        c[k++] = b[j++];
    }
}

---

复杂性是线性的，因为每个循环中的每个步骤都将一个元素复制到c数组中，总共有lena+lenb步骤。

您的任务是实现mergesort算法的合并阶段。mergesort对数据集进行排序的复杂度为ON.logN，但每个合并阶段所需的线性时间与合并集的长度成正比

下面是用于此的伪代码：

merge(array a, array b into array c)
    int i = 0, j = 0, k = 0;
    while (i < len(a) and j < len(b)) {
        if (a[i] <= b[j]) {
            c[k++] = a[i++];
        } else {
            c[k++] = b[j++];
        }
    }
    while (i < len(a)) {
        c[k++] = a[i++];
    }
    while (j < len(b)) {
        c[k++] = b[j++];
    }
}

复杂性是线性的，因为每个循环中的每个步骤都将一个元素复制到c数组中，总共有lena+lenb步骤

将两个大小不同的已排序数组A和B合并到一个 数组，线性时间中的C

您需要添加内存分配检查、空指针检查等

将两个大小不同的已排序数组A和B合并到一个 数组，线性时间中的C

---

您需要添加内存分配检查、空指针检查等。

合并排序多次执行两个排序数组的合并。您只需执行一次，就可以使用mergesort中的单个合并步骤。术语merge的正常用法是合并两个已排序的数组，合并时的排序在merge的含义上是冲突的。合并前应该进行排序，在这种情况下，可以使用任何排序算法对2个数组进行排序。如果理想情况是实现合并排序，则自下而上的方法（即原始方法）将n个元素的单个数组视为n个排序的运行，每个运行的大小为1个元素，每次通过合并偶数和奇数运行，使其大小加倍，并将运行数减半，直到生成一个已排序的运行。合并排序的平均和最大时间复杂度为*logn。但是，由于您只需要执行一个合并步骤，而不需要执行递归合并，因此时间复杂度仅为开。@gann:两个数组的大小是否相同并不重要。如果数组已经排序，则可以同时合并和排序，使用时间复杂度为On的算法。此算法与单个合并排序步骤相同。但是，如果这两个数组没有排序，则必须先进行简单的未排序合并，然后进行完整的合并排序，其时间复杂度为On*log n.@gann:谢谢你的提议，但我认为我无法改进现有的答案。可以随意接受。合并排序执行两个排序数组的多次合并。您只需执行一次，就可以使用mergesort中的单个合并步骤。术语merge的正常用法是合并两个已排序的数组，合并时的排序在merge的含义上是冲突的。合并前应该进行排序，在这种情况下，可以使用任何排序算法对2个数组进行排序。如果理想情况是实现合并排序，则自下而上的方法（即原始方法）将n个元素的单个数组视为n个排序的运行，每个运行的大小为1个元素，每次通过合并偶数和奇数运行，使其大小加倍，并将运行数减半，直到生成一个已排序的运行。合并排序的平均和最大时间复杂度为*logn。但是，由于您只需要执行一个合并步骤，而不需要执行递归合并，因此时间复杂度仅为开。@gann:两个数组的大小是否相同并不重要。如果数组已经排序，则可以同时合并和排序，使用时间复杂度为On的算法。此算法与单个合并排序步骤相同。但是，如果这两个数组没有排序，则必须先进行简单的未排序合并，然后进行完整的合并排序，其时间复杂度为On*log n.@gann:谢谢 r提议，但我认为我无法在现有答案的基础上改进。随便接受吧。

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

void sort(int *array, size_t size)
{
    qsort(array, size, sizeof(array[1]), cmpfunc);
}

int *mergeArrays(const int *array1, const int *array2, size_t size1, size_t size2, int asc)
{
    int *result = malloc((size1 + size2) * sizeof(*array1));
    size_t index1 = 0, index2 = 0;
    size_t i;


    for(i = 0; i < size1 + size2 && index1 < size1 && index2 < size2; i++)
    {   
        if(asc)
        {
            if(array1[index1] > array2[index2]) result[i] = array2[index2++];
            else result[i] = array1[index1++];
        }
        else
        {
            if(array1[index1] > array2[index2]) result[i] = array2[index2++];
            else result[i] = array1[index1++];
        }
    }
    if(index1 == size1) memcpy(result + i, array2 + index2, sizeof(result) * (size2 - index2));
    if(index2 == size2) memcpy(result + i, array1 + index1, sizeof(result) * (size1 - index1));
    return result;
}

int main(void)
{
    srand(time(NULL));
    size_t size1 = rand() % 20, size2 = rand() % 20;
    int *mergedArray;

    if(size1 < 5) size1 += 5;
    if(size2 < 5) size2 += 5;

    int array1[size1], array2[size2];

    for(size_t i = 0; i < size1; i++)
        array1[i] = rand();
    for(size_t i = 0; i < size2; i++) 
        array2[i] = rand();
    sort(array1, size1);
    sort(array2, size2);

    for(size_t i = 0; i < size1; i++)
        printf("array1[%2zu] = %d\n", i, array1[i]);
    for(size_t i = 0; i < size2; i++)
        printf("array2[%2zu] = %d\n", i, array2[i]);

    mergedArray = mergeArrays(array1, array2, size1, size2, 1);
    for(size_t i = 0; i < size2 + size1; i++)
        printf("result[%2zu] = %d\n", i, mergedArray[i]);
}