线性表

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

• 前驱元素：若A元素在B元素的前面，则称A为B的前驱元素
• 后继元素：若B元素在A元素的后面，则称B为A的后继元素

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

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

顺序表API设计
类名 SequenceList
构造方法SequenceList(int capacity)：创建容量为capacity的SequenceList对象
成员方法
1.public void clear()：空置线性表
2.publicboolean isEmpty()：判断线性表是否为空，是返回true，否返回false
3.public int length():获取线性表中元素的个数
4.public T get(int i):读取并返回线性表中的第i个元素的值
5.public void insert(int i,T t)：在线性表的第i个元素之前插入一个值为t的数据元素。
6.public void insert(T t):向线性表中添加一个元素t
7.public T remove(int i):删除并返回线性表中第i个数据元素。
8.public int indexOf(T t):返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返回-1。
成员变量
1.private T[] eles：存储元素的数组
2.private int N:当前线性表的长度

package com.vmware.list;

import java.util.Iterator;

public class SequenceList<T> implements List<T>, Iterable<T> {
    private T[] els;
    private int count;

    @SuppressWarnings(value = "unchecked")
    public SequenceList(int capacity) {
        this.els = (T[]) new Object[capacity];
    }

    @Override
    public void clear() {
        //清空数据
        for (int index = 0; index < count; index++) {
            els[index] = null;
        }
        count = 0;
    }

    @Override
    public boolean isEmpty() {
        return count == 0;
    }

    @Override
    public int length() {
        return count;
    }

    @Override
    public T get(int index) {
        return els[index];
    }

    @Override
    public void insert(T t) {
        if (count == els.length) {
            capacityExpansion(els.length << 1);
        }
        els[count++] = t;
    }

    @Override
    public void insert(T t, int index) {
        if (count == els.length) {
            capacityExpansion(els.length << 1);
        }
        //将指定索引之后的元素后移一位
        for (int start = count; start > index; start--) {
            els[start] = els[start - 1];
        }
        els[index] = t;
        count++;
    }

    @Override
    public T remove(int index) {
        T t = els[index];
        for (int i = index; i < count; i++) {
            els[i] = els[i + 1];
        }
        count--;
        if (count < els.length / 4) {
            capacityExpansion(els.length >> 1);
        }
        return t;
    }

    @Override
    public int indexOf(T t) {
        for (int i = 0; i < count; i++) {
            if (els[i] == t) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public Iterator<T> iterator() {
        return new SItr();
    }

    private class SItr implements Iterator<T> {
        private int cursor;

        public SItr() {
            cursor = 0;
        }

        @Override
        public boolean hasNext() {
            return cursor < count;
        }

        @Override
        public T next() {
            //获取元素并右移指针
            return els[cursor++];
        }
    }

    /**
     * @apiNote 扩容
     */
    @SuppressWarnings(value = "unchecked")
    private void capacityExpansion(int size) {
        T[] newArr = (T[]) new Object[size];
        //复制原数组内容
        for (int index = 0; index < count; index++) {
            newArr[index] = els[index];
        }
        els = newArr;
    }
}