恋上数据结构与算法笔记（二）：动态数组

线性表

线性表是具有 n 个相同元素的有限序列（n >= 0）。

• a1 是首节点，an是尾节点
• a1 是 a2 的前驱节点，a2 是 a1 的后继节点

数组

数组是一种顺序存储的线性表，所有元素的内存地址是连续的。几乎每一种编程语言，都有数组这种数据结构，可见它非常地常用，但是它也有缺点，那就是数组长度一但定义就无法修改。

动态数组

所谓动态数组，就是在原有数组基础上做一个改进：当数组长度不够时，能够动态扩充长度，当容量足够使用时，动态缩减长度以节约内存。

接口设计

对于接下来要实现的动态数组，它所暴露给外界的接口，有这些：

int size(); // 元素的数量
boolean isEmpty(); // 是否为空
boolean contains(E element); // 是否包含某个元素 
void add(E element); // 添加元素到最后面
E get(int index); // 返回index位置对应的元素
E set(int index, E element); // 设置index位置的元素 
void add(int index, E element); // 往index位置添加元素 
E remove(int index); // 删除index位置对应的元素
int indexOf(E element); // 查看元素的位置 
void clear(); // 清除所有元素

内部构成

ArrayList是为动态数组取的名字，它内部有一个名为elements的数组，存放在动态数组的元素实际上是存放在这个数组里面的，size属性用于标记当前动态数组的元素个数。

为什么会有个size属性？因为数组的length此时可以看做容量，也就是这个动态数组最多能够装下多少元素。而size则代表实际装入了的元素个数。

代码实现：

public class ArrayList<E> {
    // 元素的数量
    private int size;
    // 所有的元素
    private E[] elements;
    // 数组默认容量
    private static final int DEFAULT_CAPACITY = 10;
    // 元素未找到的标记常量
    private static final int ELEMENT_NOT_FOUND = -1;
    
    // 构造方法，可在外界定义数组的初始长度
    public ArrayList(int capaticy) {
        capaticy = (capaticy < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capaticy;
        elements = (E[]) new Object[capaticy];
    }
    
    // 默认的构造方法
    public ArrayList() {
    	this(DEFAULT_CAPACITY);
    }
}

一些私有方法

一些私有方法用于内部使用：

// 数组边界操作不当的异常
private void outOfBounds(int index) {
    throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}

// 用于获取、删除元素时的边界判断
private void rangeCheck(int index) {
    if (index < 0 || index >= size) {
        outOfBounds(index);
    }
}

// 用于添加元素时的边界判断
private void rangeCheckForAdd(int index) {
    if (index < 0 || index > size) {
        outOfBounds(index);
    }
}

size、isEmpty、clear 方法

// 返回数组大小
public int size() {
    return size;
}

// 动态数组是否为空
public boolean isEmpty() {
    return size == 0;
}

// 清空此动态数组
public void clear() {
    for (int i = 0; i < size; i++) {
        elements[i] = null;
    }
    size = 0;
}

添加元素

// 在数组最末尾添加元素
public void add(E element) {
    add(size, element);
}

// 在指定位置插入元素
public void add(int index, E element) {
    rangeCheckForAdd(index);
    
    // 检查容量是否还够
    ensureCapacity(size + 1);

    for (int i = size; i > index; i--) {
        elements[i] = elements[i - 1];
    }
    elements[index] = element;
    size++;
}

ensureCapacity是一个动态扩容的方法，具体实现如下：

// 保证有 capacity 的容量
private void ensureCapacity(int capacity) {
    int oldCapacity = elements.length;
    if (oldCapacity >= capacity) return;

    // 新容量为旧容量的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    E[] newElements = (E[]) new Object[newCapacity];
    // 把数组元素转移到新的数组
    for (int i = 0; i < size; i++) {
        newElements[i] = elements[i];
    }
    // 动态数组内的数组指针，指向新的数组
    elements = newElements;

    System.out.println(oldCapacity + "扩容为" + newCapacity);
}

删除元素

删除元素操作，从删除的位置起，后面的元数依次往前挪一个位置。

public E remove(int index) {
    rangeCheck(index);

    E old = elements[index];
    // 从删除的位置看，后面元素依次往前挪
    for (int i = index + 1; i < size; i++) {
        elements[i - 1] = elements[i];
    }
    elements[--size] = null;
    // 检查是否需要缩容
    trim();
    return old;
}

缩容逻辑：

// 检查是否需要缩容
private void trim() {
    int oldCapacity = elements.length;
    int newCapacity = oldCapacity >> 1;
    if (size > (newCapacity) || oldCapacity <= DEFAULT_CAPACITY) return;
    
    // 剩余空间还很多
    E[] newElements = (E[]) new Object[newCapacity];
    for (int i = 0; i < size; i++) {
        newElements[i] = elements[i];
    }
    elements = newElements;
    
    System.out.println(oldCapacity + "缩容为" + newCapacity);
}

查找元素索引、检查是否包含某元素

// 查看元素索引
public int indexOf(E element) {
    if (element == null) {  // 1
        for (int i = 0; i < size; i++) {
            if (elements[i] == null) return i;
        }
    } else {
        for (int i = 0; i < size; i++) {
            if (element.equals(elements[i])) return i; // n
        }
    }
    return ELEMENT_NOT_FOUND;
}

// 检查是否包含某元素
public boolean contains(E element) {
    return indexOf(element) != ELEMENT_NOT_FOUND;
}

获取元素、设置元素

public E get(int index) {
    rangeCheck(index);
    return elements[index];
}

public E set(int index, E element) {
    rangeCheck(index);

    E old = elements[index];
    elements[index] = element;
    return old;
}

以上代码和Java的ArrayList源码高度类似，学习它可以让开发者掌握动态数组的原理。另外Golang的数组和切片原理也是基于以上设计。