首页 > 编程笔记 > C语言笔记 阅读：570

c语言如何在数组中插一个数,或者一个值？

通义灵码

在C语言中，数组是一种固定大小的数据结构，这意味着一旦数组被创建，其大小就不能直接改变。然而，我们可以通过一些技巧来实现在数组中插入一个新的元素。

方法一：移动元素

这种方法适用于数组还有空闲空间的情况。我们需要将插入位置后的所有元素向后移动一个位置，然后在空出的位置插入新元素。

  1. #include <stdio.h>
  2.  
  3. void insertElement(int arr[], int *n, int position, int value) {
  4.     if (*n >= 100) {  // 假设数组最大容量为 100
  5.         printf("数组已满，无法插入新元素\n");
  6.         return;
  7.     }
  8.     
  9.     if (position < 0 || position > *n) {
  10.         printf("插入位置无效\n");
  11.         return;
  12.     }
  13.     
  14.     // 将 position 位置及之后的元素向后移动一个位置
  15.     for (int i = *n; i > position; i--) {
  16.         arr[i] = arr[i - 1];
  17.     }
  18.     
  19.     // 在 position 位置插入新元素
  20.     arr[position] = value;
  21.     
  22.     // 增加数组长度
  23.     (*n)++;
  24. }
  25.  
  26. int main() {
  27.     int arr[100] = {10, 20, 30, 40, 50};
  28.     int n = 5;  // 当前数组中的元素个数
  29.     
  30.     printf("插入前的数组：");
  31.     for (int i = 0; i < n; i++) {
  32.         printf("%d ", arr[i]);
  33.     }
  34.     printf("\n");
  35.     
  36.     insertElement(arr, &n, 2, 25);  // 在索引 2 的位置插入 25
  37.     
  38.     printf("插入后的数组：");
  39.     for (int i = 0; i < n; i++) {
  40.         printf("%d ", arr[i]);
  41.     }
  42.     printf("\n");
  43.     
  44.     return 0;
  45. }

这段代码定义了一个 insertElement 函数，它接受数组、数组长度的指针、插入位置和要插入的值作为参数。函数首先检查数组是否已满以及插入位置是否有效，然后，它将插入位置及其后的所有元素向后移动一个位置，为新元素腾出空间。最后，它在指定位置插入新元素并增加数组长度。


输出结果： 
插入前的数组：10 20 30 40 50 
插入后的数组：10 20 25 30 40 50

方法二：使用临时数组

如果原数组已满，我们可以创建一个更大的临时数组，将原数组的元素复制到新数组中，同时在指定位置插入新元素。

  1. #include <stdio.h>
  2.  
  3. void insertElementUsingTempArray(int arr[], int *n, int position, int value) {
  4.     int tempArr[101];  // 创建一个比原数组大 1 的临时数组
  5.     int j = 0;
  6.     
  7.     for (int i = 0; i <= *n; i++) {
  8.         if (i == position) {
  9.             tempArr[i] = value;
  10.         } else {
  11.             tempArr[i] = arr[j];
  12.             j++;
  13.         }
  14.     }
  15.     
  16.     // 将临时数组的内容复制回原数组
  17.     for (int i = 0; i <= *n; i++) {
  18.         arr[i] = tempArr[i];
  19.     }
  20.     
  21.     // 增加数组长度
  22.     (*n)++;
  23. }
  24.  
  25. int main() {
  26.     int arr[101] = {10, 20, 30, 40, 50};
  27.     int n = 5;  // 当前数组中的元素个数
  28.     
  29.     printf("插入前的数组：");
  30.     for (int i = 0; i < n; i++) {
  31.         printf("%d ", arr[i]);
  32.     }
  33.     printf("\n");
  34.     
  35.     insertElementUsingTempArray(arr, &n, 2, 25);  // 在索引 2 的位置插入 25
  36.     
  37.     printf("插入后的数组：");
  38.     for (int i = 0; i < n; i++) {
  39.         printf("%d ", arr[i]);
  40.     }
  41.     printf("\n");
  42.     
  43.     return 0;
  44. }

在这个方法中，我们创建了一个比原数组大一个元素的临时数组。我们遍历原数组，将元素复制到临时数组中，同时在指定位置插入新元素。最后，我们将临时数组的内容复制回原数组。这种方法的优点是可以处理原数组已满的情况，但缺点是需要额外的内存空间。


输出结果： 
插入前的数组：10 20 30 40 50 
插入后的数组：10 20 25 30 40 50

方法三：使用动态内存分配

如果我们不确定数组的最终大小，或者需要频繁地插入元素，使用动态内存分配可能是一个更好的选择。这种方法允许我们根据需要调整数组的大小。

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. void insertElementDynamic(int **arr, int *n, int *capacity, int position, int value) {
  5.     if (*n == *capacity) {
  6.         *capacity *= 2;
  7.         *arr = realloc(*arr, *capacity * sizeof(int));
  8.         if (*arr == NULL) {
  9.             printf("内存重新分配失败\n");
  10.             exit(1);
  11.         }
  12.     }
  13.     
  14.     for (int i = *n; i > position; i--) {
  15.         (*arr)[i] = (*arr)[i - 1];
  16.     }
  17.     
  18.     (*arr)[position] = value;
  19.     (*n)++;
  20. }
  21.  
  22. int main() {
  23.     int *arr;
  24.     int n = 0;  // 当前元素个数
  25.     int capacity = 5;  // 初始容量
  26.     
  27.     arr = (int *)malloc(capacity * sizeof(int));
  28.     if (arr == NULL) {
  29.         printf("内存分配失败\n");
  30.         return 1;
  31.     }
  32.     
  33.     // 添加一些初始元素
  34.     for (int i = 0; i < 5; i++) {
  35.         arr[i] = (i + 1) * 10;
  36.         n++;
  37.     }
  38.     
  39.     printf("插入前的数组：");
  40.     for (int i = 0; i < n; i++) {
  41.         printf("%d ", arr[i]);
  42.     }
  43.     printf("\n");
  44.     
  45.     insertElementDynamic(&arr, &n, &capacity, 2, 25);
  46.     
  47.     printf("插入后的数组：");
  48.     for (int i = 0; i < n; i++) {
  49.         printf("%d ", arr[i]);
  50.     }
  51.     printf("\n");
  52.     
  53.     printf("当前数组容量：%d\n", capacity);
  54.     
  55.     free(arr);  // 释放动态分配的内存
  56.     return 0;
  57. }

这种方法使用 malloc 和 realloc 函数来动态管理数组的内存。当数组满时，我们将其容量翻倍。这种方法的优点是可以根据需要灵活地调整数组大小，但需要注意正确管理内存以避免内存泄漏。


输出结果： 
插入前的数组：10 20 30 40 50 
插入后的数组：10 20 25 30 40 50 
当前数组容量：10

总结

以上这些方法都能够在C语言的数组中插入元素，具体选哪一种要视情况而定。
 

在选择插入方法时，需要考虑性能因素：


在实际应用中，选择哪种方法取决于具体的需求、可用内存和性能要求。对于小型数组或插入操作不频繁的情况，简单的移动元素方法可能就足够了。对于大型数组或需要频繁插入的情况，动态内存分配方法可能更合适。

相关文章