C语言中数组大小未知时动态插入元素的实现方法

要实现向大小未知的数组中插入任意数量元素、每次插入时按需扩容的逻辑，核心是手动管理底层固定大小的数组，在元素填满时自动扩容。以下是具体实现思路和示例代码：

核心逻辑 #

• 维护底层固定容量数组、当前已存储元素数量（size）、数组总容量（capacity）三个关键变量
• 每次插入元素前，检查size是否等于capacity：
  • 若相等，创建一个容量更大的新数组（通常设为原容量的2倍，平衡扩容开销和空间浪费）
  • 将原数组的所有元素复制到新数组中，替换底层数组并更新capacity
• 将新元素放入数组的size位置，然后size自增1

Java 示例代码 #

public class DynamicArray<T> {
    private T[] array;
    private int size; // 当前已存储元素数
    private int capacity; // 数组总容量

    // 初始化默认容量为10的动态数组
    public DynamicArray() {
        this.capacity = 10;
        this.array = (T[]) new Object[capacity];
        this.size = 0;
    }

    // 插入单个元素
    public void add(T element) {
        // 检查是否需要扩容
        if (size == capacity) {
            resize();
        }
        array[size] = element;
        size++;
    }

    // 扩容方法：将容量翻倍
    private void resize() {
        capacity *= 2;
        T[] newArray = (T[]) new Object[capacity];
        // 高效复制原数组元素到新数组
        System.arraycopy(array, 0, newArray, 0, size);
        array = newArray;
    }

    // 获取指定索引的元素
    public T get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index out of bounds");
        }
        return array[index];
    }

    // 获取当前元素数量
    public int size() {
        return size;
    }

    // 获取当前数组容量
    public int capacity() {
        return capacity;
    }

    public static void main(String[] args) {
        DynamicArray<Integer> dynamicArray = new DynamicArray<>();
        // 模拟插入20个元素
        for (int i = 0; i < 20; i++) {
            dynamicArray.add(i);
            System.out.printf("插入元素%d，当前容量：%d，当前元素数：%d%n", 
                i, dynamicArray.capacity(), dynamicArray.size());
        }
        // 输出所有元素
        System.out.println("所有元素：");
        for (int i = 0; i < dynamicArray.size(); i++) {
            System.out.print(dynamicArray.get(i) + " ");
        }
    }
}

Python 示例代码 #

class DynamicArray:
    def __init__(self):
        self.capacity = 10
        self.size = 0
        self.array = [None] * self.capacity

    def add(self, element):
        # 检查是否需要扩容
        if self.size == self.capacity:
            self.resize()
        self.array[self.size] = element
        self.size += 1

    # 扩容方法：将容量翻倍
    def resize(self):
        self.capacity *= 2
        new_array = [None] * self.capacity
        # 复制原数组元素
        for i in range(self.size):
            new_array[i] = self.array[i]
        self.array = new_array

    # 获取指定索引的元素
    def get(self, index):
        if index < 0 or index >= self.size:
            raise IndexError("Index out of bounds")
        return self.array[index]

    # 支持用len()获取元素数量
    def __len__(self):
        return self.size

if __name__ == "__main__":
    da = DynamicArray()
    # 模拟插入25个元素
    for i in range(25):
        da.add(i)
        print(f"插入元素{i}，当前容量：{da.capacity}，当前元素数：{len(da)}")
    # 输出所有元素
    print("所有元素：")
    for i in range(len(da)):
        print(da.get(i), end=" ")

以上代码会在每次元素填满数组时自动扩容，你可以插入任意数量的元素直到全部完成。

内容的提问来源于stack exchange，提问作者AVITAL