线性表——顺序表

一.基本介绍

  线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列。

前驱元素：

若 A 元素在 B 元素的前面，则称 A 为 B 的前驱元素

后继元素：

若 B 元素在 A 元素的后面，则称 B 为 A 的后继元素

线性表的特征：数据元素之间具有一种“ 一对一 ” 的逻辑关系。

1. 第一个数据元素没有前驱，这个数据元素被称为头结点；

2. 最后一个数据元素没有后继，这个数据元素被称为尾结点；

3. 除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和一个后继。

如果把线性表用数学语言来定义，则可以表示为 (a1,...ai-1,ai,ai+1,...an) ， ai-1 领先于 ai,ai 领先于 ai+1 ，称 ai-1 是 ai 的前驱元素，ai+1 是 ai 的后继元素。  

线性表的分类：

线性表中数据存储的方式可以是顺序存储，也可以是链式存储，按照数据的存储方式不同，可以把线性表分为顺序表和链表。

二.顺序表

顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存储线性表中的各个元素、使得线性表中再逻辑结构上响铃的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。

 代码实现：

API设计：

// 线性表API设计
public class SequenceList<T> {
    //存储元素的数组
    private T[] eles;

    //记录当前顺序表中的元素个数
    private int N;

    //构造方法(创建容量为capacity的SequenceList对象)
    public SequenceList(int capacity) {
        eles = (T[]) new Object[capacity];
        N = 0;
    }

    //将一个线性表置为空表
    public void clear() {
        N = 0;
    }

    //判断当前线性表是否为空表
    public boolean isEmpty() {
        return N == 0;
    }

    //获取线性表的长度
    public int length() {
        return N;
    }

    //获取指定位置的元素
    public T get(int i) {
        if (i < 0 || i >= N) {
            throw new RuntimeException("当前元素不存在");
        }
        return eles[i];
    }

    //向线型表中添加元素t
    public void insert(T t) {
        if (N == eles.length) {
            throw new RuntimeException("当前表已满");
        }
        eles[N++] = t;
    }

    //向线性表中插入一个元素
    public void insert(int i,T t){
        if (N == eles.length) {
            throw new RuntimeException("当前表已满");
        }
        if (i < 0 || i > N) {
            throw new RuntimeException("插入位置不合法");
        }
        //把i位置空出来，i位置及其后面的元素依次向后移动一位
        for (int index = N; index > i; index--) {
            eles[index] = eles[index - 1];
        }
        //把t放到i位置处
        eles[i] = t;
        //元素个数+1
        N++;
    }

    //删除指定位置i处的元素，并返回该元素
    public T remove(int i){
        if (i < 0 || i >= N) {
            throw new RuntimeException("当前要删除的元素不存在");
        }
        //记录i位置处的元素
        T result = eles[i];

        //把i位置后面的元素依次向前移动一位
        for (int index = i; index < N - 1; index++) {
            eles[index] = eles[index + 1];
        }
        //元素个数-1
        N--;

        return result;
    }

    //查找t元素第一次出现的位置
    public int indexOf(T t){
        if (t == null) {
            throw new RuntimeException("查找的元素不能为空");
        }
        //线性查找
        for (int i = 0; i < N; i++) {
            if (eles[i].equals(t)) {
                return i;
            }
        }
        return -1;
    }

测试代码：

 //测试代码
    public static void main(String[] args) {
        //创建顺序表对象
        SequenceList<String> sl = new SequenceList<String>(10);

        //测试插入
        sl.insert(0,"张三");
        sl.insert("李四");
        sl.insert("王五");
        sl.insert(1,"赵六");

        //测试获取
        System.out.println(sl.get(1));

        //测试删除
        System.out.println("删除的元素是："+sl.remove(0));

        //测试清空
        sl.clear();
        System.out.println("清空后的线性表中的元素个数为:"+sl.length());
    }

 控制台输出结果：

在之前的实现中，当我们使用 SequenceList 时，先 new SequenceList(5) 创建一个对象，创建对象时就需要指定容器的大小，初始化指定大小的数组来存储元素，当我们插入元素时，如果已经插入了5 个元素，还要继续插入数据，则会报错，就不能插入了。这种设计不符合容器的设计理念，因此我们在设计顺序表时，应该考虑它的容量的伸缩性。

考虑容器的容量伸缩性，其实就是改变存储数据元素的数组的大小，那我们需要考虑什么时候需要改变数组的大小？

1.添加元素时：

添加元素时，应该检查当前数组的大小是否能容纳新的元素，如果不能容纳，则需要创建新的容量更大的数组，我们这里创建一个是原数组两倍容量的新数组存储元素。

 

2.移除元素时：

移除元素时，应该检查当前数组的大小是否太大，比如正在用 100 个容量的数组存储 10 个元素，这样就会造成内存空间的浪费，应该创建一个容量更小的数组存储元素。如果我们发现数据元素的数量不足数组容量的1/4 ，则创建一个是原数组容量的1/2 的新数组存储元素。

 

 

 插入和删除的代码改进：

//改变容量
    private void resize(int newSize){
        //创建一个新的数组
        T[] newEles = (T[]) new Object[newSize];
        //把原数组中的数据复制到新数组中
        for (int i = 0; i < N; i++) {
            newEles[i] = eles[i];
        }
        //新数组替换旧数组
        eles = newEles;
    }

 //在i元素处插入元素t
    public void insert(int i,T t){
        if (i < 0 || i > N) {
            throw new RuntimeException("插入的位置不合法");
        }
        //元素已经放满了数组，需要扩容
        if (N == eles.length) {
            resize(2 * eles.length);
        }

        //把i位置空出来，i位置及其后面的元素依次向后移动一位
        for (int index = N; index > i; index--) {
            eles[index] = eles[index - 1];
        }
        
        //把t放到i位置处
        eles[i] = t;
        //元素个数+1
        N++;
    }

//删除指定位置i处的元素，并返回该元素
    public T remove(int i){
        if (i < 0 || i > N - 1) {
            throw new RuntimeException("当前要删除的元素不存在");
        }
        //记录i位置处的元素
        T result = eles[i];

        //把i位置后面的元素都向前移动一位
        for (int index = i; index < N - 1; index++) {
            eles[index] = eles[index + 1];
        }
        //元素个数-1
        N--;

        //当元素已经不足数组大小的1/4,则重置数组的大小
        if (N > 0 && N == eles.length / 4) {
            resize(eles.length / 2);
        }

        return result;
    }

顺序表的时间复杂度分析：

get(i): 不难看出，不论数据元素量 N 有多大，只需要一次 eles[i] 就可以获取到对应的元素，所以时间复杂度为 O(1);

insert(int i,T t): 每一次插入，都需要把 i 位置后面的元素移动一次，随着元素数量 N 的增大，移动的元素也越多，时间复杂为O(n);

remove(int i): 每一次删除，都需要把 i 位置后面的元素移动一次，随着数据量 N 的增大 , 移动的元素也越多，时间复杂度为O(n);

由于顺序表的底层由数组实现，数组的长度是固定的，所以在操作的过程中涉及到了容器扩容操作。这样会导致顺序表在使用过程中的时间复杂度不是线性的，在某些需要扩容的结点处，耗时会突增，尤其是元素越多，这个问题越明显。

java中ArrayList实现

java 中 ArrayList 集合的底层也是一种顺序表，使用数组实现，同样提供了增删改查以及扩容等能。