数据结构之线性表：顺序线性表 Java 实现（底层基于数组）

代码实现

package top.gldwolf.java.datastructure.lineartable;

/**
 * 顺序线性表
 * @param  存储的元素类型
 */
public class LinearTable<T> {
    private static final int INITIAL_SIZE = 20; // 线性表的初始容量
    private Object[] data = null; // 真正存储数据的数组
    private int length; // 线性表的长度
    private int cursor = 0; // 指向当前存在数据的索引的下一个，用于 append 数据

    /**
     * 创建一个默认容量大小（20）的顺序线性表
     */
    public LinearTable() {
        data = new Object[INITIAL_SIZE];
        this.length = INITIAL_SIZE;
    }

    /**
     * 创建线性表
     *
     * @param size 线性表长度
     */
    public LinearTable(int size) {
        data = new Object[size];
        this.length = size;
    }

    /**
     * 获取线性表的长度
     *
     * @return 表长度
     */
    public int length() {
        return this.length;
    }

    /**
     * 获取指定索引的数据
     *
     * @param index 索引，从 1 开始
     * @return 该索引对应位置的数据
     * @throws Exception 如果下标位置不对，则抛出该异常
     */
    public T get(int index) throws Exception {
        if (index <= 0 || index > data.length) {
            throw new Exception("下标越界");
        }
        return (T) data[index - 1];
    }

    /**
     * 在表尾部追加数据
     *
     * @param data 要添加的数据
     * @return 如果数据添加数据成，则返回 true，如果失败，则返回 false
     */
    public boolean append(T data) {
        try {
            this.data[cursor] = data;
            cursor++;
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 在指定位置插入数据
     * @param index 插入的索引位置
     * @param data 要插入的数据
     * @return 是否插入成功
     * @throws Exception 当索引越界或表已满时
     */
    public boolean insert(int index, T data) throws Exception {
        if (index <= 0 || index > length || cursor > length - 1 || this.data[index - 1] != null) { // 下标越界或表已满
            throw new Exception("下标越界或线性表已满！");
        } else if (index == length) { // 当插入的位置为最后一个元素时
            this.data[index - 1] = data;
            cursor ++;
            return true;
        } else { // 当下标不越界，并且数组未满时
            for (int i = cursor; i >= index - 1; i--) {
                this.data[i + 1] = this.data[i];
            }
            this.data[index - 1] = data;
            this.cursor++;
            return true;
        }
    }

    /**
     * 删除指定索引的数据
     * @param index 索引位置
     * @return 删除是否成功
     * @throws Exception 索引越界时
     */
    public boolean delete(int index) throws Exception {
        if (index <= 0 || index > length) { // 当索引越界时
            throw new Exception("下标越界！");
        } else if (index == length) { // 当要删除的为最后一个元素时
            data[index - 1] = null;
            return true;
        } else { // 当删除的不是最后一个时
            for (int i = index - 1; i < length - 1; i++) {
                data[i] = data[i + 1];
            }
            data[length - 1] = null;
            return true;
        }
    }

    @Override
    public String toString() {
       StringBuffer res = new StringBuffer();
        	for (Object t : data) {
            	res.append(t + ", ");
        	}
        return res.toString();
    }
}

测试类

package top.gldwolf.java.datastructure.lineartable;

/**
 * @author: Gldwolf
 * @email: [email protected]
 * @date: 2020/4/14 19:11
 */

public class LinearTableDriver {
    public static void main(String[] args) throws Exception {
        LinearTable<String> table = new LinearTable<>(5);
        table.append("hello");
        table.append("world");
        table.append("you");
        System.out.println(table.toString());
        table.insert(2, "good");
        System.out.println("------------");
        System.out.println(table.toString());
        System.out.println("------------");
        table.insert(5, "last");
        System.out.println(table.toString());
        table.delete(5);
        System.out.println(table.toString());
        table.delete(2);
        System.out.println(table.toString());
    }
}