请将刚刚那段代码改写为归并排序

下面是将之前的代码改写为归并排序的版本：

void merge(EMPLOYEE** arr, int left, int mid, int right, int order) {
    int i, j, k;
    int n1 = mid - left + 1;
    int n2 = right - mid;

    EMPLOYEE* L[n1];
    EMPLOYEE* R[n2];

    for (i = 0; i < n1; i++) {
        L[i] = arr[left + i];
    }
    for (j = 0; j < n2; j++) {
        R[j] = arr[mid + 1 + j];
    }

    i = 0;
    j = 0;
    k = left;

    while (i < n1 && j < n2) {
        switch (order) {
        case ASCEND:
            if (L[i]->employeeId <= R[j]->employeeId) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
            }
            break;
        case DESCEND:
            if (L[i]->employeeId >= R[j]->employeeId) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
            }
            break;
        default:
            printf("Wrong order code!");
            break;
        }
        k++;
    }

    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

void mergeSort(EMPLOYEE** arr, int left, int right, int order) {
    if (left < right) {
        int mid = left + (right - left) / 2;

        mergeSort(arr, left, mid, order);
        mergeSort(arr, mid + 1, right, order);

        merge(arr, left, mid, right, order);
    }
}

void sortById(DOUBLE_LINK_LIST* list, int order) {
    if (list->size <= 1) {
        return;
    }

    EMPLOYEE** arr = (EMPLOYEE**)malloc(list->size * sizeof(EMPLOYEE*));
    LINKED_NODE* current = list->head;
    int i = 0;

    while (current != NULL) {
        arr[i] = (EMPLOYEE*)current->data;
        current = current->nextNode;
        i++;
    }

    mergeSort(arr, 0, list->size - 1, order);

    current = list->head;
    i = 0;

    while (current != NULL) {
        current->data = arr[i];
        current = current->nextNode;
        i++;
    }

    free(arr);
}

这个改写的版本使用归并排序算法对双向链表中的EMPLOYEE结构体按照employeeId进行排序。

归并排序是一种分治算法，它将待排序的数组递归地分成两半，然后分别对两个子数组进行排序，最后将两个有序的子数组合并成一个有序数组。在这个改写的代码中，我们使用了自顶向下的递归实现。

`merge`函数用于将两个有序的子数组合并成一个有序数组。它接受待排序数组`arr`、左边界`left`、中间位置`mid`、右边界`right`和排序顺序`order`作为参数。在合并的过程中，根据传入的`order`参数，比较左右两个子数组中元素的大小，并按顺序将它们放入临时数组中。

`mergeSort`函数用于对子数组进行排序，它接受待排序数组`arr`、左边界`left`、右边界`right`和排序顺序`order`作为参数。在递归的过程中，将数组逐渐分成更小的子数组，直到子数组只包含一个元素。然后，将这些子数组按照顺序进行合并。

`sortById`函数是对外的排序函数。它首先将双向链表中的数据复制到一个临时的数组中，然后调用`mergeSort`函数对数组进行排序。排序完成后，再将排好序的数据重新放回到双向链表中。

需要注意的是，在这个改写的版本中，我们使用了动态内存分配来创建临时数组，并在排序完成后释放这块内存空间。