顺序表

class SeqList{
    private int maxSize;
    private int size;
    private Object[] listArray;

    //构造函数
    public SeqList(int size){
        maxSize = size;
        listArray = new Object[size];
        size = 0;
    }

    //插入
    public void insert(int index,Object obj) throws Exception{
        if(size == maxSize){
            throw new Exception("顺序表已满无法插入！");
        }
        if(index<0 || index>size){
            throw new Exception("参数错误！");
        }
        for(int j=size;j>index;j--){
            listArray[j] = listArray[j-1];
        }
        listArray[index] = obj;
        size++;
    }

    //删除
    public Object delete(int index) throws Exception {  

        if(size == 0){
            throw new Exception("链表为空无法删除！");
        }

        if(index<0 || index>size-1){
            throw new Exception("参数有误！");
        }

        Object it = listArray[index];
        for(int j=index;j<size-1;j++){
            listArray[j] = listArray[j+1];
        }

        size--;
        return it;
    }

    //获取元素
    public Object getData(int index) throws Exception { 
        if(index<0 || index>size-1){
            throw new Exception("参数有误！");
        }
        return listArray[index];
    }

    //获取元素个数
    public int size() { 
        return size;
    }

    //是否为空
    public boolean isEmpty() {  
        return size == 0;
    }

}

//测试类
public class Demo{
    public static void main(String[] args) {
        try {
            SeqList seqList = new SeqList(3);
            seqList.insert(0, new Integer(1));
            seqList.insert(1, new Integer(2));
            seqList.insert(2, 3);
            System.out.println(seqList.isEmpty());
            System.out.println("listArray[1] = "+seqList.getData(1));
            System.out.println("listArray[2] = "+seqList.getData(2));
            System.out.println("size = "+seqList.size());
            System.out.println("delete listArray[0] = "+seqList.delete(0));
        } catch (Exception e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
    }
}

运行结果：

false
listArray[1] = 2
listArray[2] = 3
size = 3
delete listArray[0] = 1

效率分析

在顺序表中插入一个数据元素时，主要耗时的是循环移动数据元素部分。最坏情况是index = 0，需移动size个数据元素；最好情况是index = size，需移动0个数据元素；平均次数为 n/2

在顺序表中删除一个数据元素时，主要耗时的是循环移动数据元素部分。最坏情况是index = 0，需移动size-1个数据元素；最好情况是index = size，需移动0个数据元素；平均次数为 (n-1)/2

顺序表其他操作都和数据元素个数n无关，因此，插入和删除函数的时间复杂度为O(n)

顺序表支持随机读取，因此，读取函数的时间复杂度为O(1)

优点：支持随机读取，以及空间利用率高

缺点：需要预先给出数组的最大数据元素个数，但数组的最大数据元素个数很难准确给出，另外，插入和删除操作时需要移动较多的数据元素