编程实现：将有序数组有序合并。 1)​有两个从小到大的整型有序数组a和b，编一子函数将这两个数组合并为从小到大的有序数组c，整个合并过程中c保持有序； 2)​子函数头要求为void merge(int a[],int b[],int c[],int m,int n)，m用来传递a数组元素个数，n传递b数组元素个数。

以下是实现代码：

void merge(int a[], int b[], int c[], int m, int n) {
    int i = 0, j = 0, k = 0;
    while (i < m && j < n) {
        if (a[i] < b[j]) {
            c[k++] = a[i++];
        } else {
            c[k++] = b[j++];
        }
    }
    while (i < m) {
        c[k++] = a[i++];
    }
    while (j < n) {
        c[k++] = b[j++];
    }
}

该函数的实现过程如下：

首先定义三个指针i、j、k，分别指向a、b、c数组的开头。

然后在循环中，比较a[i]和b[j]的大小，若a[i]小于b[j]，则将a[i]加入到c数组中，i和k都加1；否则将b[j]加入到c数组中，j和k都加1。

最后，若a数组还有剩余元素，则将剩余元素加入到c数组中；若b数组还有剩余元素，则将剩余元素加入到c数组中。

最终，c数组中就是a数组和b数组合并后的有序数组。

相关问题

用Java实现以下描述：给定两个长度相同的整型有序数组a和b，实现一个函数，函数返回数组a和b合并后的有序数组的两个中位数之和，要求空间复杂度为O（1）

这里是一个Java实现，满足给定要求：

public static double findMedianSortedArrays(int[] a, int[] b) {
    int m = a.length, n = b.length;
    if (m > n) {
        int[] temp = a; a = b; b = temp;
        int tmp = m; m = n; n = tmp;
    }
    int iMin = 0, iMax = m, halfLen = (m + n + 1) / 2;
    while (iMin <= iMax) {
        int i = (iMin + iMax) / 2;
        int j = halfLen - i;
        if (i < iMax && b[j-1] > a[i]){
            iMin = i + 1;
        } else if (i > iMin && a[i-1] > b[j]) {
            iMax = i - 1;
        } else {
            int maxLeft = 0;
            if (i == 0) { maxLeft = b[j-1]; }
            else if (j == 0) { maxLeft = a[i-1]; }
            else { maxLeft = Math.max(a[i-1], b[j-1]); }
            if ((m + n) % 2 == 1) { return maxLeft; }

            int minRight = 0;
            if (i == m) { minRight = b[j]; }
            else if (j == n) { minRight = a[i]; }
            else { minRight = Math.min(b[j], a[i]); }

            return (maxLeft + minRight) / 2.0;
        }
    }
    return 0.0;
}

public static double findMedianSortedArraysSum(int[] a, int[] b) {
    double median = findMedianSortedArrays(a, b);
    if ((a.length + b.length) % 2 == 1) {
        return 2 * median;
    } else {
        double left = findMedianSortedArrays(a, b, (a.length + b.length) / 2 - 1);
        double right = median;
        return left + right;
    }
}

这里用到了二分查找的思想来找到两个有序数组的中位数。我们首先对长度较小的数组进行二分查找，确定其中位数的位置，然后通过计算可以得到另一个数组中的中位数的位置。接下来，我们根据两个中位数的值进行判断，可以将两个数组分为左右两个部分。如果左半部分的最大值小于右半部分的最小值，那么我们就找到了合并后的有序数组的中位数。如果数组长度之和是奇数，中位数就是唯一的数值，直接返回；否则，需要再次查找得到中位数左边的数，将两个中位数相加即为所求的两个中位数之和。

编写一函数实现对起始地址是a,长度是n的整型数组从小到大排序。

下面是一个简单的选择排序的实现：

void sort(int *a, int n) {
    int i, j, min_idx;
    for (i = 0; i < n-1; i++) {
        min_idx = i;
        for (j = i+1; j < n; j++) {
            if (a[j] < a[min_idx]) {
                min_idx = j;
            }
        }
        int temp = a[i];
        a[i] = a[min_idx];
        a[min_idx] = temp;
    }
}

其中，变量`min_idx`表示当前未排序部分中最小元素的下标。在每一轮循环中，找到未排序部分的最小元素，将其与未排序部分的第一个元素交换。循环结束后，数组就被排序了。可以通过调用该函数来对任意整型数组进行排序。

注意：该实现并不是最优的排序算法，时间复杂度为O(n^2)，在实际应用中可能会有更好的排序算法选择。