算法学习——动态数组和静态数组
基本数据结构
对于标准库的常用数据结构，力扣平台都会默认导入。也就是说，你在写算法题时，可以直接使用 vector、set、map 等关键字创建数据结构。
动态数组 vector
vector 是 C++ 标准库的动态数组。
大家以前学 C 语言的时候肯定学过 malloc, int[n] 等方式来创建静态数组，但是这种方式非常麻烦，而且容易出错。我们做算法题的时候一般使用动态数组 vector，而且题目给的输入一般也是 vector 类型。
关于动态数组和静态数组的区别，我会在后文 实现动态数组 的章节中详细介绍。
动态数组是静态数组的强化版，也是我们在实际软件开发或者写算法题时最常用的数据结构之一。
首先，你不要以为动态数组可以解决静态数组在中间增删元素效率差的问题，不可能解决的。数组随机访问的超能力源于数组连续的内存空间，而连续的内存空间就不可避免地面对数据搬移和扩缩容的问题。
// 创建动态数组
// 不用显式指定数组大小，它会根据实际存储的元素数量自动扩缩容
vector<int> arr;
for (int i = 0; i < 10; i++) {
// 在末尾追加元素，时间复杂度 O(1)
arr.push_back(i);
}
// 在中间插入元素，时间复杂度 O(N)
// 在索引 2 的位置插入元素 666
arr.insert(arr.begin() + 2, 666);
// 在头部插入元素，时间复杂度 O(N)
arr.insert(arr.begin(), -1);
// 删除末尾元素，时间复杂度 O(1)
arr.pop_back();
// 删除中间元素，时间复杂度 O(N)
// 删除索引 2 的元素
arr.erase(arr.begin() + 2);
// 根据索引查询元素，时间复杂度 O(1)
int a = arr[0];
// 根据索引修改元素，时间复杂度 O(1)
arr[0] = 100;
// 根据元素值查找索引，时间复杂度 O(N)
int index = find(arr.begin(), arr.end(), 666) - arr.begin();
在实际使用动态数组时，缩容也是重要的优化手段。比方说一个动态数组开辟了能够存储 1000 个元素的连续内存空间，但是实际只存了 10 个元素，那就有 990 个空间是空闲的。为了避免资源浪费，我们其实可以适当缩小存储空间，这就是缩容。
在实际使用动态数组时，缩容也是重要的优化手段。比方说一个动态数组开辟了能够存储 1000 个元素的连续内存空间，但是实际只存了 10 个元素，那就有 990 个空间是空闲的。为了避免资源浪费，我们其实可以适当缩小存储空间，这就是缩容。
我们这里就实现一个简单的扩缩容的策略：
- 当数组元素个数达到底层静态数组的容量上限时，扩容为原来的 2 倍；
- 当数组元素个数缩减到底层静态数组的容量的 1/4 时，缩容为原来的 1/2。
#include <iostream>
#include <stdexcept>
#include <vector>
template<typename E>
class MyArrayList {
private:
// 真正存储数据的底层数组
E* data;
// 记录当前元素个数
int size;
// 最大元素容量
int cap;
// 默认初始容量
static const int INIT_CAP = 1;
public:
MyArrayList() {
this->data = new E[INIT_CAP];
this->size = 0;
this->cap = INIT_CAP;
}
MyArrayList(int initCapacity) {
this->data = new E[initCapacity];
this->size = 0;
this->cap = initCapacity;
}
// 增
void addLast(E e) {
// 看 data 数组容量够不够
if (size == cap) {
resize(2 * cap);
}
// 在尾部插入元素
data[size] = e;
size++;
}
void add(int index, E e) {
// 检查索引越界
checkPositionIndex(index);
// 看 data 数组容量够不够
if (size == cap) {
resize(2 * cap);
}
// 搬移数据 data[index..] -> data[index+1..]
// 给新元素腾出位置
for (int i = size - 1; i >= index; i--) {
data[i + 1] = data[i];
}
// 插入新元素
data[index] = e;
size++;
}
void addFirst(E e) {
add(0, e);
}
// 删
E removeLast() {
if (size == 0) {
throw std::out_of_range("NoSuchElementException");
}
// 可以缩容，节约空间
if (size == cap / 4) {
resize(cap / 2);
}
E deletedVal = data[size - 1];
// 删除最后一个元素
// 必须给最后一个元素置为 null，否则会内存泄漏
data[size - 1] = E();
size--;
return deletedVal;
}
E remove(int index) {
// 检查索引越界
checkElementIndex(index);
// 可以缩容，节约空间
if (size == cap / 4) {
resize(cap / 2);
}
E deletedVal = data[index];
// 搬移数据 data[index+1..] -> data[index..]
for (int i = index + 1; i < size; i++) {
data[i - 1] = data[i];
}
data[size - 1] = E();
size--;
return deletedVal;
}
E removeFirst() {
return remove(0);
}
// 查
E get(int index) {
// 检查索引越界
checkElementIndex(index);
return data[index];
}
// 改
E set(int index, E element) {
// 检查索引越界
checkElementIndex(index);
// 修改数据
E oldVal = data[index];
data[index] = element;
return oldVal;
}
// 工具方法
int getSize() {
return size;
}
bool isEmpty() {
return size == 0;
}
// 将 data 的容量改为 newCap
void resize(int newCap) {
E* temp = new E[newCap];
for (int i = 0; i < size; i++) {
temp[i] = data[i];
}
// 释放原数组内存
delete[] data;
data = temp;
cap = newCap;
}
bool isElementIndex(int index) {
return index >= 0 && index < size;
}
bool isPositionIndex(int index) {
return index >= 0 && index <= size;
}
// 检查 index 索引位置是否可以存在元素
void checkElementIndex(int index) {
if (!isElementIndex(index)) {
throw std::out_of_range("Index out of bounds");
}
}
// 检查 index 索引位置是否可以添加元素
void checkPositionIndex(int index) {
if (!isPositionIndex(index)) {
throw std::out_of_range("Index out of bounds");
}
}
void display() {
std::cout << "size = " << size << " cap = " << cap << std::endl;
for (int i = 0; i < size; i++) {
std::cout << data[i] << " ";
}
std::cout << std::endl;
}
~MyArrayList() {
delete[] data;
}
};
int main() {
// 初始容量设置为 3
MyArrayList<int> arr(3);
// 添加 5 个元素
for (int i = 1; i <= 5; i++) {
arr.addLast(i);
}
arr.remove(3);
arr.add(1, 9);
arr.addFirst(100);
int val = arr.removeLast();
// 100 1 9 2 3
for (int i = 0; i < arr.getSize(); i++) {
std::cout << arr.get(i) << std::endl;
}
return 0;
}
静态数组
API（应用程序接口，Application Programming Interface）是一组定义、规则和协议，用于在不同软件系统之间进行互动和通信。
「静态数组」就是一块连续的内存空间，我们可以通过索引来访问这块内存空间中的元素，这才是数组的原始形态。
而「动态数组」是编程语言为了方便我们使用，在静态数组的基础上帮我们添加了一些常用的 API，比如 push, insert, remove 等等方法，这些 API 可以让我们更方便地操作数组元素，不用自己去写代码实现这些操作。
// 用 memset 函数把数组的值初始化为 0
memset(arr, 0, sizeof(arr));
如果不用 memset 这种函数初始化数组的值，那么数组内的值是不确定的。因为 int arr[10] 这个语句只是请操作系统在内存中开辟了一块连续的内存空间，你也不知道这块空间是谁使用过的二手内存，你也不知道里面存了什么奇奇怪怪的东西。所以一般我们会用 memset 函数把这块内存空间的值初始化一下再使用。
当然，上面讲的这些内容都是针对 C/C++，因为大家学习计算机基础的时候都接触过。其他比如 Java Golang 这种语言，静态数组创建出来后会自动帮你把元素值都初始化为 0，所以不需要再显式进行初始化。
我梳理一下上面的因果逻辑，静态数组本质上就是一块连续的内存空间，int arr[10] 这个语句我们可以得知：
1、我们知道这块内存空间的首地址（数组名 arr 就指向这块内存空间的首地址）。
2、我们知道了每个元素的类型（比如 int），也就是知道了每个元素占用的内存空间大小（比如一个 int 占 4 字节，32 bit）。
3、这块内存空间是连续的，其大小为 10 * sizeof(int) 即 40 字节。
所以，我们获得了数组的超能力「随机访问」：只要给定任何一个数组索引，我可以在 O(1)*O*(1) 的时间内直接获取到对应元素的值。
因为我可以通过首地址和索引直接计算出目标元素的内存地址。计算机的内存寻址时间可以认为是 O(1)O(1)，所以数组的随机访问时间复杂度是 O(1)O(1)。
但是，一个人最大的优势往往也是他的最大劣势。数组连续内存的特性给了他随机访问的超能力，但它也因此吃了不少苦，下面介绍。
「数据搬移」
不行的，连续内存必须一次性分配，分配完了之后就不能随意增减了。
只能重新申请一块更大的内存空间，把原来的数据复制过去，再插入新的元素，这就是数组的「扩容」操作。
浙公网安备 33010602011771号