数据结构之线性表-顺序存储

本人文笔较差，语文从来不及格，基础不好，写此类文章仅供自己学习，理解队列及其他知识，高手大神请略过。参考书籍 《数据结构与算法分析-Java语言描述》

1.1 线性表简介

线性表是0个或多个元素的有限序列。即元素之间有顺序且有限。假设表中有元素A₁，A₂，A₃，....，A_N，若存在1<i<N,则 A_i 是 A_i-1的直接后继，A_i-1 是A_i的直接前驱。作为线性表，必须满足A₁没有前驱，A_N没有后继（有限性）。N是线性表的长度。当N=0时，即表中没有任何元素也即空表。

1.2 线性表的顺序存储

在内存中用一段地址连续的存储单元依次存储线性表的数据元素。如每天上下班挤地铁排成一条长队，有时候几个要好的同事接连的站在一起。其他人就占据不了这几个位置了。转换成计算机语言就是在内存中找了一块地儿，把这段内存空间给占了，然后把相同数据类型的元素（暂且理解成通用Object类型）放在这块儿地儿。用数组实现，第一个人就存储在下标是0的那个位置，线性表的长度就是人数。此时在等地铁的时候又遇到一个同事，我们让他(她)跟我们一起，于是线性表的长度就加了1，但是事先已经定义了数组的长度，即内存中只占了我们几个人空间，这时有个同事看向左侧一排发现没人，就带着我们过去排队，然后我们都能排在一起了。即重新定义了数组，内存中多占了块儿地儿。另一种情况是，突然有个同事内急去上厕所，我们就多余占了一个位置。即线性表的长度是不断变化的，而数组要预先占好足够多的空间。所以线性表的长度总是小于或等于数组的长度。

存储器中的每个存储单元都有自己的编号，当在没有重写toString方法时，打印一个实例得到的结果，即内存地址。确定任何一个元素位置了，就可以通过编号计算其他任意元素的位置了。即它获取元素的时间复杂度是O(1)。

假设之前那个同事占据了好几十个人的空间，我们只有m个人现在考虑前面的插入问题即突然又来了一位同事，若插在最后一个同事位置后面（这里假设它站过来需要t时间，t是个固定常数），这时其他同事都不用动，时间复杂度即是常数O(1),若插在中间的某个位置k(0<k<m)，则k之前的同事也不用动，但是k之后的m-k个同事每一个都要向后挪一位，用时(m-k)*t的时间，最费时情况的是他（她）若插到最前面的那个同事前面，我们每一个人都将向后挪动一个位置将耗时m*t，所以平均耗时m*t/2, 平均时间复杂度即O(N)，N是规模，这里是同事的人数m。当然移除元素即每个元素向前挪，和插入一样，平均时间复杂度都是O(N)。

至此，就明白了，基本的线性表顺序存储(其实其他结构的存储也是)就包括插入，删除，获取元素及获取表的长度的几个操作。Java代码的简单实现：

/**
 * Created with IntelliJ IDEA.
 * CreateUser:  blentle
 * Email: renhuan@milipp.com
 * CreateTime:  2014/11/6 12:40
 * ModifyUser:  blentle
 * ModifyTime:  2014/11/6 12:40
 * Class Description:
 * To change this template use File | Settings | File Templates.
 */
public class SequenceList<T> {
    //不指定存储空间时的默认存储，操作时越界暂时将抛出异常
    private static final int DEFAULT_CAPACITY = 10;
    //线性表的最大长度（数组的长度）
    private int capacity;
    //线性表元素的个数
    private int size;
    //存储线性表元素的数组
    private Object[] elementData;

    /**
     * 使用默认的最大存储空间，超过最大存储空间将抛出异常
     */
    public SequenceList() {
        this(DEFAULT_CAPACITY);
    }

    /**
     *
     * @param initialCapacity 最大存储空间初始化
     */
    public SequenceList(int initialCapacity) {
        this.capacity = initialCapacity;
        this.elementData = new Object[capacity];
    }

    /**
     *
     * @return 线性表的长度
     */
    public int size() {
        return this.size;
    }

    /**
     *
     * @return 线性表是否是空表
     */
    public boolean isEmpty() {
        return this.size == 0;
    }

    /**
     * 获取元素
     * @param index
     * @return T
     */
    public T get(int index) {
        //检查序号是否越界,注意inde是从0开始
        if(index >= size) {
            throw new IndexOutOfBoundsException("index is :"+ index + "but size is:" + this.size);
        }
        return elementData(index);
    }

    public boolean add(int index,T element) {
        //检查序号是否越界,注意inde是从0开始,最大值是size-1
        if(index > size || index < 0) {
            throw new IndexOutOfBoundsException("index is :"+ index + ",but size is:" + this.size);
        }
        //若链表已满(元素个数等于数组初始化最大容量，一般ArrayList继续扩展容量，这里抛出异常)
        if(size == capacity) {
            throw new IndexOutOfBoundsException("list is full...");
        }
        if(index == size) {
            //插在表尾
            elementData[size] = element;
        } else {
            //插在其他地方，index后面的的每一个元素向后挪一位
            for(int i = size + 1 ; i > index ; i--) {
                elementData[i] = elementData[i-1];
            }
        }
        //index位置被替换成element
        elementData[index] = element;
        size++;
        return true;
    }

    /**
     * 不指定插入位置，插入表尾
     * @param t 链表元素
     * @return
     */
    public boolean add(T t) {
        return add(size,t);
    }

    /**
     * 从表中移除元素
     * @param index 元素序号
     * @return
     */
    public boolean remove(int index) {
        if(index >= size || index < 0) {
            throw new IndexOutOfBoundsException("index is :"+ index + ",but size is:" + this.size);
        }
        for(int k = index ; k < size - 1 ; k++) {
            elementData[k] = elementData[k + 1];
        }
        elementData[size - 1] = null;
        size--;
        return true;
    }

    /**
     * 清空线性表
     */
    public void clear() {
        if(size > 0) {
            for(int i = 0 ; i < size ; i ++) {
                elementData[i] = null;
            }
            size = 0;
        }
    }

    @Override
    public String toString() {
        String a = "";
        for(int i = 0 ; i < size() ; i ++) {
            a += (T)elementData[i] + " ";
        }
        return a;
    }

    /**
     * 获取元素并强制转换的封装（参考ArrayList源码）
     * @param index
     * @return
     */
    private T elementData(int index) {
        return (T) elementData[index];
    }
}

1.3 从代码可以看出线性表的特点

• 快速地从表中获取任意位置的元素。
• 插入和删除操作需要移动大量的元素。
• 当表的长度变化比较大时，不太好确定存储空间的容量（数组的初始化大小）