Java线性表（顺序存储）——数组实现

第一次写博客，最近一直在研究数据结构，最开始准备用c语言写数据数据结构的东西的，发现用c真的写得我头痛，果断用了我喜欢的java实现，其实懂了过后用什么语言写都一样的。不说了，直接上代码！

---

1.定义接口

抽象数据类型的List接口

public interface List {
    
    //返回线性表的大小，即数据元素的个数
    public int getSize();
    
    //判断线性表是否为空
    public boolean isEmploy();
    
    //判断线性表是否包含元素e
    public boolean contains(Object se);
    
    //返回数据元素e在线性表中的序号，若不存在返回-1
    public int indexOf(Object e);
    
    //将数据元素e插入到线性表的i个位置，越界则报错
    public void insert(int i,Object e) throws OutOfBoundaryException;
    
    //将数据元素e插入到元素obj之前
    public boolean insertBefor(Object obj,Object e);
    
    //将数据元素插入到元素obj之后
    public boolean insertAfter(Object obj,Object e);
    
    //删除线性表中序号为i的元素，成功则返回这个元素，i越界报错
    public Object remove(int i) throws OutOfBoundaryException;
    
    //删除线性表中第一个与元素e相同的元素，成功true ,失败flase
    public boolean remove(Object e);
    
    //替换线性表中序号为i的元素e，成功则返回原数据，i越界报错
    public Object replace(int i,Object e) throws OutOfBoundaryException;
    
    //返回线性表中序号为i的元素，i越界报错
    public Object get(int i) throws OutOfBoundaryException;
}
 

2.定义异常

出现越界发生该异常

public class OutOfBoundaryException extends RuntimeException{

    public OutOfBoundaryException(String err){
        super(err);
    }
}

3.用数组实现

public class ListArray implements List {

    // 数组默认大小
    private final int LEN = 8;

    // 数组元素的比较策略(没用上，用的系统的比较方法)
    // private Strategy strategy;

    // 线性表中元素的个数
    private int size;

    // 数据元素数组
    private Object[] elements;

    public ListArray() {
    }

    public ListArray(int size) {
        // this.strategy = strategy;
        this.size = size;
        elements = new Object[LEN];
    }

    /*
     * 返回线性表大小
     */
    public int getSize() {
        return size;
    }

    /*
     * 判断线性表是否为空
     */
    public boolean isEmploy() {
        return size == 0;
    }

    /*
     * 判断线性表是否包含元素e
     */
    public boolean contains(Object e) {
        for (int i = 0; i < size; i++) {
            if (e.equals(elements[i]))
                return true;
        }
        return false;
    }

    /*
     * 返回元素e在线性表中的序号
     */
    public int indexOf(Object e) {
        for (int i = 0; i < size; i++)
            if (e.equals(elements[i]))
                return i;
        return -1;
    }

    /*
     * 在线性表的i个序号位置插入元素e
     */
    public void insert(int i, Object e) throws OutOfBoundaryException {
        if (i < 0 || i > size)
            throw new OutOfBoundaryException("越界异常");
        if (size >= elements.length)
            expandSpace();// 表满了，扩容两倍
        for (int j = size; j > i; j--)
            elements[j] = elements[j - 1];
        elements[i] = e;
        size++;
        return;
    }

    /*
     * 数组扩容两倍
     */
    public void expandSpace() {
        Object[] a = new Object[elements.length * 2];
        for (int i = 0; i < elements.length; i++)
            a[i] = elements[i];
        elements = a;
    }

    /*
     * 将数据e插入到元素obj之前
     */
    public boolean insertBefor(Object obj, Object e) {
        int i = indexOf(obj);
        System.out.println(i);
        if (i < 0)
            return false;
        insert(i, e);
        return true;
    }

    /*
     * 将数据e插入到元素obj之后
     */
    public boolean insertAfter(Object obj, Object e) {
        int i = indexOf(obj);
        if (i < 0)
            return false;
        insert(i + 1, e);
        return true;
    }

    /*
     * 删除序号为i的那个元素
     */
    public Object remove(int i) throws OutOfBoundaryException {
        if (i < 0 || i > size) {
            throw new OutOfBoundaryException("输入的数越界");
        }
        Object obj = elements[i];
        for (int j = i; j < size - 1; j++)
            elements[j] = elements[j + 1];
        // elements[--size] = null;//?我用size--替换
        size--;
        return obj;
    }

    /*
     * 删除线性表第一个与e相同的元素
     */
    public boolean remove(Object e) {
        int i = indexOf(e);
        if (i < 0)
            return false;
        remove(i);
        return true;
    }

    /*
     * 替换序号为i的元素e
     */
    public Object replace(int i, Object e) throws OutOfBoundaryException {
        if (i < 0 || i > size)
            throw new OutOfBoundaryException("输入越界");
        Object obj = elements[i];
        elements[i] = e;
        return obj;
    }

    /*
     * 返回序列号为i的元素
     */
    public Object get(int i) throws OutOfBoundaryException {
        if (i < 0 || i > size)
            throw new OutOfBoundaryException("数组越界");
        return elements[i];
    }

}

这里我没有写理论知识，我觉得写太多的文字大家也不会去太仔细的阅读，如果需要请留言给我！