数据结构(1)--- 线性表顺序表

线性表是具有相同特性的数据元素的一个有限序列,该序列中含有的元素个数叫做线性表的长度.
一般来说哦我们线性表都会分为两种结构存储,一个顺序结构,一个是链式结构.
而我们今天的内容主要是关于顺序存储结构的—顺序表.
其实在Java中我们对应得ArrayList数组就是利用这种特性的.
一般来说需要我们区分去注意的就是以下几点:
1. 我们需要先固定顺序表的长度,所以这样的弊端就是我们的长度存在限制
2. 连续地址存储,所以可以说对空间的浪费比较少
3. 因为我们的随机访问时通过下标访问的,所以时间复杂度为O(1),也是比较省事有效

     /**
 *  1. 初始化定义顺序表长度
 *  2. 判断空方法
 *  3. 获取长度方法
 *  4. 实现插入、删除、获取数据的方法
 * @author Administrator
 * 
 */
        public class SequenceList {
        // 默认最大长度
        final int defaultSize = 10;
        // 最大长度
        int maxSize;
        // 当前长度
        int currentSize;
        // 对象数组
        Object[] listArray;

        // 利用构造函数初始化
        public SequenceList() {
            init(defaultSize);
        }

        public SequenceList(int currentSize) {
            init(currentSize);
        }

        // 顺序表的初始方法,用来确定存在的元素个数
        private void init(int currentSize) {
            // TODO Auto-generated method stub
            maxSize = currentSize;
            this.currentSize = 0;
            listArray = new Object[maxSize];
        }

        // 判断是否为空,长度为空
        public boolean isEmpty() {
            return currentSize == 0;
        }

        // 插入操作
        public void insert(int index, Object object) {
            if (currentSize == maxSize) {
                System.out.println("顺序表已满,无法插入");
            }
            if (index < 0 || index > maxSize) {
                System.out.println("插入位置不合理");
            }
            // 剩下就是插入成功后,移动后面的元素,将每一个index后的元素都能向后以为,就是
            // 将元素i的值变成了元素i+1的值,之所以j等于Current-1是不想要越界
            for (int j = currentSize - 1; j >= index; j--) {
                listArray[j + 1] = listArray[j];
            }
            listArray[index] = object;
            currentSize++; // 长度+1
        }

        // 删除操作
        public void delete(int index) {
            if (isEmpty()) {
                System.out.println("顺序表为空,无法删除");
                if (index < 0 || index > maxSize - 1) {
                    System.out.println("位置存在错误");
                }
                for (int j = index; j < currentSize - 1; j++) {
                    listArray[j] = listArray[j + 1];
                }
                currentSize--;

            }
        }

        public Object get(int index) {
            if (index < 0 || index >= maxSize) {
                System.out.println("参数错误");
            }
            return listArray[index];

        }

        // 获取顺序表长度
        public int getSize() {
            return currentSize;

        }

        // 测试
        public static void main(String[] args) {
            SequenceList sequenceList = new SequenceList(20);
            sequenceList.insert(12, "小明");
            Object f = sequenceList.get(12);
            sequenceList.insert(13, "小明");
            int size = sequenceList.getSize();
            System.out.println(f);
            System.out.println(size);

        }
    }

思想:
1. 因为顺序表的位置相对开始就是固定的,假如需要插入,就要将后面的元素进行后移(这就需要使用我们的for循环),长度改变.
2. 对应的假如我们删除元素,我们后面的元素就要前移,长度改变
3. 注意上面的长度指的是我们当前的长度,其实我们一开始定义的最大长度还没有到达,不然就会报错,因为最大长度是固定的.

优缺点比较:
1. 顺序表的优点是：支持随机访问；空间利用率高（连续分配，不存在空间浪费）。
2. 顺序表的缺点是：大小固定（一开始就要固定顺序表的最大长度）；插入和删除元素需要移动大量的数据。