线性表的顺序存储

线性表的顺序存储

线性表的顺序存储结构：用一段地址连续的存储单元依次存储线性表的数据元素。

线性表的元素类型相同，用一段连续的地址存储，可以使用数组来存储实现线性表的顺序存储。
线性表的存储结构代码如下。

class MyArrayList{
	private final static int MAXSIZE = 2;			//线性表数组的初始长度,这里设置2是为了测试
	int[] data;						//存储数据元素  data元素的类型根据实际情况来定，这里假设用int
	int size;						//存储线性表当前长度
}

数组长度和线性表当前长度的区别，数组长度指的是数组可以容纳的最大存储容量，线性表长度指的是线性表中数据元素的个数，随着插入和删除的操作，进行变化。
在任意时刻，线性表的长度不大于数组的长度。

线性表的插入和删除

插入：时间复杂度为O(1)

• 如果插入位置不合理，抛出异常
• 如果线性表满了，则扩容
• 从最后一个元素开始遍历到第index位置，分别将他们向后移动一个位置，将要插入的元素填入index处
• 表长加1

删除：时间复杂度为O(1)

• 如果删除位置不合理，抛出异常
• 从要删除的位置开始遍历到最后一个元素位置，分别将他们都向前移动一个位置
• 表长减1
• 返回删除的元素

线性表顺序存储的优缺点：

优点：

1. 无须为表示表中元素之间的逻辑关系而额外增加存储空间
2. 可以快速查找任意位置的元素

缺点：

1. 插入和删除元素要移动大量元素
2. 当线性表长度变化较大时，难以确定存储空间的容量
3. 造成存储空间的碎片。

我用java简单的实现了一下线性表顺序存储的增删改查等操作，下面是源代码。

public class MyArrayList {
    private final static int MAXSIZE = 2;
    int[] data;
    int size;
    public MyArrayList(){
        this(MAXSIZE);
    }
    public MyArrayList(int num){
        data = new int[num];
        size = 0;
    }
    //获取当前列表大小
    public int size(){
        return size;
    }
    //判断列表是否为空
    public boolean isEmpty(){
        return size == 0;
    }
    //获取指定下标的元素
    public int get(int index){
        if (index < size)
            return data[index];
        else
            throw new IndexOutOfBoundsException();
    }
    public boolean isFull(){
        return size == data.length;
    }
    //插入
    public boolean add(int num){
        if (isFull())
            grow();
        data[size++] = num;
        return true;
    }

    public boolean add(int index,int num){
        if (isFull())
            grow();
        size++;
        for (int i=size;i>index;i--){
            data[i] = data[i-1];
        }
        data[index] = num;
        return true;
    }
    //删除
    public int delete(int index){
        int oldData = data[index];
        if (isEmpty()){
            throw new NullPointerException();
        }else{
            if (index < size && index >= 0){
                for (int i=index+1;i<data.length-1;i++){
                    data[i-1] = data[i];
                }
                size--;
            }else{
                throw new ArrayIndexOutOfBoundsException();
            }
        }
        return oldData;
    }
    //修改
    public int set(int index, int num){
        int oldData = data[index];
        if (index < size && index >= 0){
            data[index] = num;
        }
        return oldData;
    }
    //查找
    public int indexOf(int index){
        if (index < size && index >= 0)
            return data[index];
        else
            throw new ArrayIndexOutOfBoundsException();
    }
    //扩容
    private void grow() {
        data = Arrays.copyOf(data,data.length*2);       //数组扩容为原来的2倍
    }
    //输出列表内容
    public void show(){
        for (int i=0;i<size;i++){
            System.out.println(data[i]);
        }
    }
}

测试代码

public class ArrayListTest {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(1);
        myArrayList.add(2);
        myArrayList.add(0, 0);
       /* System.out.println(myArrayList.indexOf(4));
        System.out.println(myArrayList.get(1));
        System.out.println(myArrayList.size());*/
        /*myArrayList.show();
        myArrayList.delete(1);*/
        myArrayList.show();
        myArrayList.set(1,3);
        myArrayList.show();
    }
}