c语言中如何合并两个整数数组例题

在C语言中，合并两个整数数组的过程包括以下步骤：创建足够大的目标数组、遍历并将两个源数组的元素复制到目标数组中、处理重复元素或排序。如果需要合并的数组较大，可能还需要考虑内存管理问题。下面将详细描述合并两个整数数组的具体实现方法。

一、理解数组合并的基本概念

在编程中，数组合并是一项常见的操作。合并两个数组意味着将两个数组的元素结合成一个新数组。在C语言中，数组是一种数据结构，可以存储相同类型的多个元素。合并两个整数数组的主要步骤包括：

创建一个足够大的目标数组：目标数组的大小应至少是两个源数组大小之和。
遍历源数组并复制元素：将两个源数组的元素逐个复制到目标数组中。
处理重复元素或排序：根据需要处理重复元素或对目标数组进行排序。

二、创建足够大的目标数组

在C语言中，数组的大小在声明时必须固定，因此在合并两个数组之前，需要先确定目标数组的大小。假设我们有两个整数数组arr1和arr2，其大小分别为n1和n2，则目标数组的大小应为n1 + n2。

#include <stdio.h>
int main() {
    int arr1[] = {1, 3, 5};
    int arr2[] = {2, 4, 6};
    int n1 = sizeof(arr1) / sizeof(arr1[0]);
    int n2 = sizeof(arr2) / sizeof(arr2[0]);
    int n3 = n1 + n2;
    int arr3[n3];
    // Code to merge arrays will go here
    return 0;
}

三、遍历并复制元素

接下来，我们需要遍历两个源数组，并将它们的元素复制到目标数组中。我们可以使用两个for循环来实现这一点。

#include <stdio.h>
int main() {
    int arr1[] = {1, 3, 5};
    int arr2[] = {2, 4, 6};
    int n1 = sizeof(arr1) / sizeof(arr1[0]);
    int n2 = sizeof(arr2) / sizeof(arr2[0]);
    int n3 = n1 + n2;
    int arr3[n3];
    // Copy elements of arr1 to arr3
    for (int i = 0; i < n1; i++) {
        arr3[i] = arr1[i];
    }
    // Copy elements of arr2 to arr3
    for (int i = 0; i < n2; i++) {
        arr3[n1 + i] = arr2[i];
    }
    // Print the merged array
    printf("Merged array: ");
    for (int i = 0; i < n3; i++) {
        printf("%d ", arr3[i]);
    }
    return 0;
}

四、处理重复元素或排序

在某些情况下，合并后的数组可能需要去重或排序。这里以排序为例，使用冒泡排序对合并后的数组进行排序。

#include <stdio.h>
// Function to sort array using bubble sort
void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // Swap arr[j] and arr[j+1]
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
int main() {
    int arr1[] = {1, 3, 5};
    int arr2[] = {2, 4, 6};
    int n1 = sizeof(arr1) / sizeof(arr1[0]);
    int n2 = sizeof(arr2) / sizeof(arr2[0]);
    int n3 = n1 + n2;
    int arr3[n3];
    // Copy elements of arr1 to arr3
    for (int i = 0; i < n1; i++) {
        arr3[i] = arr1[i];
    }
    // Copy elements of arr2 to arr3
    for (int i = 0; i < n2; i++) {
        arr3[n1 + i] = arr2[i];
    }
    // Sort the merged array
    bubbleSort(arr3, n3);
    // Print the sorted merged array
    printf("Sorted merged array: ");
    for (int i = 0; i < n3; i++) {
        printf("%d ", arr3[i]);
    }
    return 0;
}

五、内存管理和优化

在处理较大的数组时，静态数组可能会导致栈溢出。这时可以使用动态内存分配来创建目标数组。

#include <stdio.h>
#include <stdlib.h>
// Function to sort array using bubble sort
void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // Swap arr[j] and arr[j+1]
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
int main() {
    int arr1[] = {1, 3, 5};
    int arr2[] = {2, 4, 6};
    int n1 = sizeof(arr1) / sizeof(arr1[0]);
    int n2 = sizeof(arr2) / sizeof(arr2[0]);
    int n3 = n1 + n2;
    // Allocate memory for the merged array
    int *arr3 = (int *)malloc(n3 * sizeof(int));
    if (arr3 == NULL) {
        printf("Memory allocation failed");
        return 1;
    }
    // Copy elements of arr1 to arr3
    for (int i = 0; i < n1; i++) {
        arr3[i] = arr1[i];
    }
    // Copy elements of arr2 to arr3
    for (int i = 0; i < n2; i++) {
        arr3[n1 + i] = arr2[i];
    }
    // Sort the merged array
    bubbleSort(arr3, n3);
    // Print the sorted merged array
    printf("Sorted merged array: ");
    for (int i = 0; i < n3; i++) {
        printf("%d ", arr3[i]);
    }
    // Free the allocated memory
    free(arr3);
    return 0;
}

六、使用函数封装合并逻辑

为了提高代码的可读性和可重用性，可以将合并数组的逻辑封装到一个函数中。

#include <stdio.h>
#include <stdlib.h>
// Function to sort array using bubble sort
void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // Swap arr[j] and arr[j+1]
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
// Function to merge two arrays
int* mergeArrays(int arr1[], int n1, int arr2[], int n2) {
    int n3 = n1 + n2;
    int *arr3 = (int *)malloc(n3 * sizeof(int));
    if (arr3 == NULL) {
        printf("Memory allocation failed");
        return NULL;
    }
    // Copy elements of arr1 to arr3
    for (int i = 0; i < n1; i++) {
        arr3[i] = arr1[i];
    }
    // Copy elements of arr2 to arr3
    for (int i = 0; i < n2; i++) {
        arr3[n1 + i] = arr2[i];
    }
    // Sort the merged array
    bubbleSort(arr3, n3);
    return arr3;
}
int main() {
    int arr1[] = {1, 3, 5};
    int arr2[] = {2, 4, 6};
    int n1 = sizeof(arr1) / sizeof(arr1[0]);
    int n2 = sizeof(arr2) / sizeof(arr2[0]);
    // Merge the arrays
    int *arr3 = mergeArrays(arr1, n1, arr2, n2);
    if (arr3 == NULL) {
        return 1;
    }
    // Print the sorted merged array
    printf("Sorted merged array: ");
    int n3 = n1 + n2;
    for (int i = 0; i < n3; i++) {
        printf("%d ", arr3[i]);
    }
    // Free the allocated memory
    free(arr3);
    return 0;
}

七、处理重复元素

在某些情况下，可能需要去除合并后的数组中的重复元素。可以使用一个辅助数组来存储唯一元素，然后将其复制回目标数组。

#include <stdio.h>
#include <stdlib.h>
// Function to sort array using bubble sort
void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // Swap arr[j] and arr[j+1]
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
// Function to remove duplicates from a sorted array
int removeDuplicates(int arr[], int n) {
    if (n == 0) return 0;
    int j = 0;
    for (int i = 1; i < n; i++) {
        if (arr[i] != arr[j]) {
            j++;
            arr[j] = arr[i];
        }
    }
    return j + 1;
}
// Function to merge two arrays
int* mergeArrays(int arr1[], int n1, int arr2[], int n2, int *n3) {
    *n3 = n1 + n2;
    int *arr3 = (int *)malloc(*n3 * sizeof(int));
    if (arr3 == NULL) {
        printf("Memory allocation failed");
        return NULL;
    }
    // Copy elements of arr1 to arr3
    for (int i = 0; i < n1; i++) {
        arr3[i] = arr1[i];
    }
    // Copy elements of arr2 to arr3
    for (int i = 0; i < n2; i++) {
        arr3[n1 + i] = arr2[i];
    }
    // Sort the merged array
    bubbleSort(arr3, *n3);
    // Remove duplicates
    *n3 = removeDuplicates(arr3, *n3);
    return arr3;
}
int main() {
    int arr1[] = {1, 3, 5, 5};
    int arr2[] = {2, 4, 6, 6};
    int n1 = sizeof(arr1) / sizeof(arr1[0]);
    int n2 = sizeof(arr2) / sizeof(arr2[0]);
    int n3;
    // Merge the arrays
    int *arr3 = mergeArrays(arr1, n1, arr2, n2, &n3);
    if (arr3 == NULL) {
        return 1;
    }
    // Print the sorted merged array without duplicates
    printf("Sorted merged array without duplicates: ");
    for (int i = 0; i < n3; i++) {
        printf("%d ", arr3[i]);
    }
    // Free the allocated memory
    free(arr3);
    return 0;
}

八、总结

合并两个整数数组在C语言中是一个常见的操作，主要涉及创建目标数组、复制元素、排序和去重等步骤。在处理较大的数组时，应注意内存管理问题。通过封装函数，可以提高代码的可读性和可重用性。希望以上内容能帮助你更好地理解和实现数组合并操作。