数据结构（1）-线性表（顺序存储结构）

概念：指的是用一段地址连续的存储单元依次存储线性表的数据元素；用一维数组来实现顺序存储结构；
重要属性：存储空间的起始位置、线性表的最大存储量、线性表的当前长度；
优点：无须为表示表中元素之间的逻辑关系而增加额外的存储空间；可以快速的查看任意位置的元素。
缺点：插入和删除操作需要移动大量元素；当线性表长度变化比较大时，难以确定存储空间的容量；造成存储空间的“碎片”；

/*
 * 1. 顺序结构（数组）实现单链表
 */
public class MyArrayList<T> {

    public static void main(String[] args) {
        MyArrayList<String> list = new MyArrayList<String>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.insert("ddd", 2);
        list.remove();
        System.out.println(list);
        System.out.println(list.locate("aaa"));
    }

    private static final int DEFAULT_SIZE = 10;// 数组的默认长度
    private int size;// 记录元素的个数
    private int capacity;// 记录数组的长度
    private Object[] elementData;// 保存元素的数组

    // 以默认数组长度创建空顺序线性表
    public MyArrayList() {
        capacity = DEFAULT_SIZE;
        elementData = new Object[capacity];
    }

    // 以一个初始化元素来创建顺序表
    public MyArrayList(T element) {
        this();// 调用上面的无参构造函数
        elementData[0] = element;
        size++;
    }

    // 以初始化元素和初始大小创建顺序线性表
    public MyArrayList(int initSize, T element) {
        capacity = 1;
        while (capacity < initSize) {
            capacity <<= 1;// //把capacity设为大于initSize的最小的2的n次方
        }
        elementData = new Object[capacity];
        elementData[0] = element;
        size++;
    }

    // 获取线性表元素的个数
    public int length() {
        return size;
    }

    // 获取顺序线性表中索引为i出的元素
    public T getValue(int i) {
        if (i < 0 || i > size - 1) {
            throw new IndexOutOfBoundsException("线性表索引越界");
        }
        return (T) elementData[i];
    }

    // 查找顺序线性表中制指定元素的索引
    public int locate(T element) {
        for (int i = 0; i < size; i++) {
            if (elementData[i].equals(element))
                return i;
        }
        return -1;
    }

    // 向线性表的指定位置插入一个元素
    public void insert(T element, int index) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("线性表索引越界");
        }
        ensureCapacity(size + 1);
        // 将index处以后的所有元素向后移动一格
        System.arraycopy(elementData, index, elementData, index + 1, size
                - index);
        elementData[index] = element;
        size++;
    }

    // 在线性顺序表开始添加一个元素
    public void add(T element) {
        insert(element, size);
    }

    // 扩充底层数组长度
    private void ensureCapacity(int minCapacity) {
        // 如果数组的原有长度小于目前所需长度
        if (minCapacity > capacity) {
            // 不断的将capacity*2，直到capacity大于minCapacity为止
            while (capacity < minCapacity) {
                capacity <<= 1;
            }
            elementData = Arrays.copyOf(elementData, capacity);
        }
    }

    // 删除顺序线性表中指定索引出的元素
    public T delete(int index) {
        if (index < 0 || index > size - 1) {
            throw new IndexOutOfBoundsException("线性表索引越界");
        }
        T oldValue = (T) elementData[index];
        int numMoved = size - index - 1;
        if (numMoved > 0) {
            System.arraycopy(elementData, index + 1, elementData, index,
                    numMoved);
        }
        elementData[--size] = null;// 清空最后一个元素
        return oldValue;
    }

    // 删除最后一个元素
    public T remove() {
        return delete(size - 1);
    }

    // 判断线性表是否为空表
    public boolean empty() {
        return size == 0;
    }

    // 清空线性表
    public void clear() {
        Arrays.fill(elementData, null);
        size = 0;
    }

    // 重写toString方法
    public String toString() {
        if (size == 0) {
            return "[]";
        } else {
            StringBuilder sb = new StringBuilder("[");
            for (int i = 0; i < size; i++) {
                sb.append(elementData[i].toString() + ",");
            }
            int len = sb.length();
            return sb.delete(len - 1, len).append("]").toString();
        }
    }
}