数据结构（一、线性表

定义的接口

package com.brrbaii.service;


public interface SequenceList<T> {

    /**
     * 清空线性表
     */
    void clear();

    /**
     * 判断当前线性表是否为空
     */
    boolean isEmpty();

    /**
     * 获取线性表个数
     */
   int length();

    /**
     * 获取第Index个元素内容
     * @param index           ：下标
     */
    T get(int index);

    /**
     * 插入一个数据
     * @param t               ：数据
     */
    void insert(T t);

    /**
     * 在第Index个元素之前插入一个数据
     * @param t               ：数据
     * @param Index           ：下标
     */
    void insert(T t, int Index);

    /**
     * 删除并返回当前元素
     * @param Index           ：下标
     */
    T remove(int Index);

    /**
     * 返回指定元素首次出现的位置
     */
    int indexOf(T t);

    /**
     * 先序遍历
     */
    void prePrint();

    /**
     * 判满
     */
    boolean isFull();

    /**
     * 扩容
     */
    T[] expand(int capacity);

}

 实现类

package com.brrbaii.service.Imp;

import com.brrbaii.service.SequenceList;
import org.springframework.stereotype.Service;

import java.util.Arrays;

@Service
public class SequenceListImp<T> implements SequenceList {

    private T[] eles;
    //当前线性表的长度
    private int N;

    public SequenceListImp(int capacity) {
        this.eles = (T[])new Object[capacity] ;
        N = 0;
    }

    /**
     * 清空线性表
     */
    @Override
    public void clear() {
        this.N = 0;
    }

    /**
     * 判断当前线性表是否为空
     */
    @Override
    public boolean isEmpty() {
        return this.N == 0;
    }

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

    /**
     * 获取第Index个元素内容
     * @param index           ：下标
     */
    @Override
    public T get(int index) {
        return eles[index];
    }

    /**
     * 末尾插入一个元素
     * @param o
     */
    @Override
    public void insert(Object o) {
        if (isFull()){
            eles = expand(eles.length*2);
        }
        eles[N++] = (T) o;
    }

    /**
     * 指定位置添加一个元素
     * @param o
     */
    @Override
    public void insert(Object o, int Index) {
        if (isFull()){
            eles = expand(eles.length * 2);
        }
        //移动Index索引后所有元素，腾出空间
        for(int i = this.N; i > Index ; i--){
            eles[i] = eles[i-1];
        }
        N++;
        eles[Index] = (T) o;

    }

    /**
     * 删除并返回当前元素
     * @param Index           ：下标
     */
    // A B C D E
    @Override
    public Object remove(int Index) {
        T removeValue = eles[Index];
        for(int i = Index; i < N-1; i++){
            eles[i] = eles[i+1];
        }
        N--;
        return removeValue;
    }

    /**
     * 返回指定元素首次出现的位置
     */
    @Override
    public int indexOf(Object o) {
        for(int i = 0; i < this.N; i++){
            if(eles[i].equals((T) o )){
                return i;
            }
        }
        return -1;
    }

    /**
     * 正序遍历
     */
    public void prePrint(){
        for(int i = 0; i < N ; i++){
            System.out.print(eles[i]+"  ");
        }

    }

    /**
     * 判满
     */
    @Override
    public boolean isFull() {
        return this.N == this.eles.length;
    }


    /**
     * 扩容
     */
    public T[] expand(int newSize){
        T[] newArr = (T[])new Object[newSize];
        N = 0;
        for(int i = 0 ; i < eles.length; i++){
            newArr[i] = eles[i];
            N++;
        }

        return newArr;
    }

    @Override
    public String toString() {
        return "SequenceListImp{" +
                "eles=" + Arrays.toString(eles) +
                ", N=" + N +
                '}';
    }
}