c两个数组合并成一个有序数组并去重

假设两个数组分别为arr1和arr2，以下是一种可能的实现方法：

1. 将arr1和arr2合并为一个数组arr3：

arr3 = arr1 + arr2

2. 对arr3进行排序：

arr3.sort()

3. 去重：

arr3 = list(set(arr3))

完整代码如下：

arr1 = [1, 3, 5, 7, 9]
arr2 = [2, 4, 6, 8, 10]
arr3 = arr1 + arr2
arr3.sort()
arr3 = list(set(arr3))
print(arr3)

输出：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

相关问题

已知两个整型数组A与B，请将两个数组合并后去重，并对合并后的数组从小到大排序

当你需要合并两个整数数组A和B并去除其中的重复元素，然后按照升序排列结果，你可以通过以下步骤完成：

1. **合并数组**：
首先，创建一个新的空数组C，用于存储合并后的结果。遍历数组A和B，将每个元素依次添加到数组C中。

2. **去重**：
对于数组C中的每个元素，使用哈希集合（如Python的set或Java的HashSet）来检查它是否已经存在。如果不存在，则添加到结果数组中。这样可以保证数组中不会有重复的元素，因为哈希集合只存储唯一的值。

3. **排序**：
使用内置的排序函数对数组C进行排序。在大多数语言中，数组都是有序容器，所以可以直接调用sort()方法（例如Python的`sorted()`或Java的`Arrays.sort()`）按自然顺序排序。如果是升序，不需要指定额外的比较规则。

以下是一个简单的Python示例代码实现这个过程：

def merge_and_sort(A, B):
    C = A + B  # 合并数组
    C = list(set(C))  # 去重
    C.sort()  # 排序
    return C

# 示例
array_A = [1, 3, 5]
array_B = [2, 4, 6]
result = merge_and_sort(array_A, array_B)
print(result)  # 输出: [1, 2, 3, 4, 5, 6]

C语言合并数组并且转为有序去重集合

以下是一个示例代码，用于将两个数组合并为一个有序且去重的集合：

#include <stdio.h>

void merge(int arr1[], int len1, int arr2[], int len2, int result[], int *len) {
    int i = 0, j = 0, k = 0;
    while (i < len1 && j < len2) {
        if (arr1[i] < arr2[j]) {
            result[k++] = arr1[i++];
        } else if (arr1[i] > arr2[j]) {
            result[k++] = arr2[j++];
        } else {
            result[k++] = arr1[i++];
            j++;
        }
    }
    while (i < len1) {
        result[k++] = arr1[i++];
    }
    while (j < len2) {
        result[k++] = arr2[j++];
    }
    *len = k;
}

void sort(int arr[], int len) {
    int i, j, temp;
    for (i = 0; i < len - 1; i++) {
        for (j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

void dedup(int arr[], int *len) {
    int i, j;
    for (i = 0, j = 0; j < *len; j++) {
        if (arr[i] != arr[j]) {
            arr[++i] = arr[j];
        }
    }
    *len = i + 1;
}

int main() {
    int arr1[] = {1, 3, 5, 7, 9};
    int len1 = sizeof(arr1) / sizeof(arr1[0]);

    int arr2[] = {2, 4, 6, 8, 10};
    int len2 = sizeof(arr2) / sizeof(arr2[0]);

    int result[100];
    int len = 0;

    merge(arr1, len1, arr2, len2, result, &len);
    sort(result, len);
    dedup(result, &len);

    int i;
    for (i = 0; i < len; i++) {
        printf("%d ", result[i]);
    }
    printf("\n");

    return 0;
}

在这个示例中，我们首先定义了两个数组 `arr1` 和 `arr2`，并分别计算它们的长度。然后我们定义了一个 `result` 数组，用于存放合并后的结果。我们还定义了一个 `len` 变量，用于表示 `result` 数组的长度。

我们调用了 `merge` 函数，将 `arr1` 和 `arr2` 合并到 `result` 数组中，同时更新了 `len` 变量。然后我们调用了 `sort` 函数，将 `result` 数组排序。最后我们调用了 `dedup` 函数，将 `result` 数组去重。

在 `dedup` 函数中，我们使用了两个指针 `i` 和 `j`，分别表示当前已经去重过的元素的末尾位置和当前正在处理的元素的位置。我们从头开始遍历数组，如果当前元素不等于前一个已经去重过的元素，就将它加入到已去重的序列中。

最后，我们打印了去重后的结果。