线性表的物理存储结构之顺序表实现

上篇文章里写了线性表的物理结构是顺序表和链表。这篇我们详细看下顺序表的物理实现，用Java试着实现一个ArrayList。

 

再把定义搬过来下。

 

线性表是由大于等于0的n个同类型数据元素组成的有限序列。

 

首先，线性表是同类型的，要么全部存字符串，要么全部存整型或者其他等等。其次线性表是顺序的且是有容量限制的，不是无止境的。

如果没有元素，称为空表。如果存在多个元素，则第一个元素无前驱，最后一个元素无后继，其他元素元素都有且只有一个前驱和后继。

 

优缺点或者啥特性的不说了，看前面的文章。

 

下面来看下线性表的逻辑实现：

线性表有具体的数据元素占坑，然后需要一个下标来记录数据元素装载的位置。

大概功能就有增、删、改、查，判空，元素个数等，见下面代码：

package com.shuyangyang.structure;

/**
 * 自己实现线性表接口
 *
 * @author shuyangyang
 * @version 1.0.0
 * @date 2020-3-28 13:09:38
 */
public interface MyList<T> {

    /**
     * 数组里的元素个数
     *
     * @return {@code int} 元素数量
     */
    int size();

    /**
     * 是否为空数组
     *
     * @return {@code true 空 false 非空}
     */
    boolean isEmpty();

    /**
     * 往数组结尾添加一个元素
     *
     * @param element 元素
     */
    void add(T element);

    /**
     * 往数组指定位置添加元素
     *
     * @param index   数组下标
     * @param element 元素
     */
    void add(int index, T element);

    /**
     * 获取数组指定下标的元素
     *
     * @param index 数组下标
     * @return 元素
     */
    T get(int index);

    /**
     * 移除数组指定位置元素
     *
     * @param index 数组下标
     */
    void remove(int index);

    /**
     * 数组字符串输出
     *
     * @return 数组字符串
     */
    String listToString();
}

线性表是有限序列，那么当然需要定义长度，元素个数和一个序列对象，如下：

/**
 * 自己实现线性表结构，顺序数组
 *
 * @author shuyangyang
 * @version 1.0.0
 * @date 2020-3-28 13:30:24
 */
public class MyArrayList<T> implements MyList<T> {

    // 数组初始化容量为10
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 使用一个数组来实现当前ArrayList
     */
    private Object[] elementData;

    /**
     * 数组里的元素个数
     */
    private int size;

    MyArrayList() {
        size = 0;
        elementData = new Object[DEFAULT_CAPACITY];
    }
}

下面我们主要讲添加数据元素，添加数据元素分为2种情况：

1、从左往右添加，一个接着一个

这种情况最需要考虑的就是扩容问题，如果顺序表满了，我们怎么办，是不是需要扩容？扩容多少呢？

@Override
    public void add(T element) {
        this.add(size, element);
    }

    @Override
    public void add(int index, T element) {
        // 如果当前数组元素个数超过数组最大容量，那么需要扩容
        if (this.size >= elementData.length) {
            Object[] oldElementData = elementData;
            // 新数组扩容量为旧数组的2倍
            elementData = new Object[oldElementData.length * 2];
            // 声明一个新数组，将旧数组的值按顺序填充进来
            for (int i = 0; i < size(); i++) {
                elementData[i] = oldElementData[i];
            }
        }

        // 如果数组从中间某一位置添加元素，那么数组后面元素需要整体后移
        if (index != size) {
            for (int j = size; j > index; j--) {
                elementData[j] = elementData[j - 1];
            }
        }

        // 继续向数组后面追加元素
        elementData[index] = element;
        // 指针向后移动1位
        size++;
    }

这里我写的是扩容2倍，我通过查看ArrayList源码发现，源码中有2种情况，如果指定增长值就按照增长值扩容，没有就扩容原数组的一半。具体代码就不贴了，大家可以在ArrayList源码中寻找。

2、任意位置添加一个

如果是尾添加，那么好办，基本和第一种情况一样。如果任意位置添加，那么就需要后移数据元素了，见下图：

如果6想在2和3中间加入，那么3后面的数据元素整体都要往后移动一位，空出一个位置给6进来，这样就实现了任意位置插入了，具体代码见上面的add(int index, T element)方法实现。

 

那么删除数据元素呢？其实和添加类似，只是反过来思维，见下图：

 

如果删除3，那么所有数据元素需要往前移动，具体代码：

@Override
    public void remove(int index) {
        // 删除类似中间插入，删除一个数，那么数组后面的元素向前移动，size减一

        if (index < 0 || index > elementData.length) {
            throw new MyArrayIndexOutOfBoundsException("数组越界异常：" + index);
        }

        for (int i = index; i < elementData.length - 1; i++) {
            elementData[i] = elementData[i+1];
        }

        // 指针向前移动1位
        size--;
    }

弄懂了扩容，任意位置插入元素，其他基本就不难了，最后我们测试下我们的程序：

package com.shuyangyang.structure;

public class TestMyArrayList {

    public static void main(String[] args) {
        MyList<Integer> list = new MyArrayList<Integer>();
        list.add(111);
        list.add(222);
        list.add(333);
        list.add(444);
        list.add(555);
        list.add(7777);
        list.add(888);
        list.add(9999);
        list.add(10112);

        System.out.println(list.isEmpty());
        list.add(5, 666);
        list.add(1, 456);
        System.out.println(list.listToString());

        list.remove(8);
        System.out.println(list.listToString());
        System.out.println(list.get(8));
        System.out.println("list.size() =>" + list.size());

    }
}

最终结果：

PS：上面代码为了方便学习，没有优化代码，完整代码可以从我的码云上下载：https://gitee.com/shuyangyang/algorithm