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

本人文笔较差，语文从来不及格，基础不好，写此类文章仅供自己学习，理解队列及其他知识，高手大神请略过。参考书籍 《数据结构与算法分析-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: [email protected]

 * 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 从代码可以看出线性表的特点

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