数据结构顺序表Java实现

Posted 2020-06-17

Java实现顺序表算法：
1:首先我们需要定义我们的接口，关于顺序表的一些基本的操作：顺序表中的操作都有增删改查。

//List接口
public interface IList {
    //返回线性表的大小,即数据元素的个数。 
    public int getSize();
    //如果线性表为空返回 true,否则返回 false。 
    public boolean isEmpty(); 
    //判断线性表是否包含数据元素 e
    public boolean contains(Object e);
    //返回数据元素 e 在线性表中的序号
    public int indexOf(Object e);
    //将数据元素 e 插入到线性表中 i 号位置
    public void insert(int i, Object e) throws OutOfBoundaryException; 
    //将数据元素 e 插入到元素 obj 之前
    public boolean insertBefore(Object obj, Object e); 
    //将数据元素 e 插入到元素 obj 之后
    public boolean insertAfter(Object obj, Object e); 
    //删除线性表中序号为 i 的元素,并返回之
    public Object remove(int i) throws OutOfBoundaryException; 
    //删除线性表中第一个与 e 相同的元素
    public boolean remove(Object e);
    //替换线性表中序号为 i 的数据元素为 e,返回原数据元素
    public Object replace(int i, Object e) throws OutOfBoundaryException; 
    //返回线性表中序号为 i 的数据元素
    public Object get(int i) throws OutOfBoundaryException;
}

2.我们在这里还需要比较元素的大小，我们就写一个比较元素大小的策略的接口。

//对象比较策略接口
public interface IStrategy {
    //判断两个数据元素是否相等
    public boolean equal(Object obj1, Object obj2);
    /**
     * 比较两个数据元素的大小 * 如果 obj1 < obj2 返回-1
     * 如果obj1 = obj2 返回0
     * 如果obj1 > obj2 返回1
     */
    public int compare(Object obj1, Object obj2);
}

3.写我们这里需要的策略的实现。

/**
 * 默认比较策略类
 */
public class DefaultStrategy implements IStrategy {

    @Override
    public boolean equal(Object obj1, Object obj2) {
        return obj1.equals(obj2);
    }

    @Override
    public int compare(Object obj1, Object obj2) {
        return obj1.toString().compareTo(obj2.toString());
    }

}

4.我们策略已经写完，下一步我们就写我们顺序表的实现。

//顺序表类
public class MyArrayList implements IList{

    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }
    private final int LEN = 8;     //数组的默认大小
    private IStrategy strategy; //数据元素比较策略  
    private int size;             //线性表中数据元素的个数
    private Object[] elements;     //数据元素数组
    //构造方法
    public MyArrayList(){
        this(new DefaultStrategy());
    }
    
    public MyArrayList(IStrategy strategy){
        this.strategy = strategy;
        size = 0;
        elements = new Object[LEN];
    }
    @Override
    public int getSize() {
        // TODO Auto-generated method stub
        return this.size;
    }

    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return size == 0;
    }

    @Override
    public boolean contains(Object e) {
        // TODO Auto-generated method stub
        for(int i = 0; i < size; i++){
            if(this.strategy.equal(e, elements[i])){
                return true;
            }
        }
        return false;
    }

    @Override
    public int indexOf(Object e) {
        // TODO Auto-generated method stub
        for( int i = 0; i < size; i++){
            if(strategy.equal(e, elements[i])){
                return i;
            }
        }
        return -1;
    }

    @Override
    public void insert(int i, Object e) throws OutOfBoundaryException {
        // TODO Auto-generated method stub
        //检查下标越界
        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++; //元素个数加1
    }
    //扩展顺序表空间
    private void expandSpace(){
        Object[] a = new Object[elements.length*2]; 
        for (int i=0; i<elements.length; i++) {
            a[i] = elements[i];
        }
        elements = a;
    }
    @Override
    public boolean insertBefore(Object obj, Object e) {
        // TODO Auto-generated method stub
        //找到插入位置
        int i = indexOf(obj); 
        if (i<0) {
            return false;
        }
        insert(i,e);
        return true;
    }

    @Override
    public boolean insertAfter(Object obj, Object e) {
        // TODO Auto-generated method stub
        int i = indexOf(obj); 
        if (i<0) {
            return false;
        }
        insert(i+1,e); 
        return true;
    }

    @Override
    public Object remove(int i) throws OutOfBoundaryException {
        // TODO Auto-generated method stub
        //首先检查越界
        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;
        return obj;
    }

    @Override
    public boolean remove(Object e) {
        // TODO Auto-generated method stub
        //找到被删除数据元素的位置
        int i = indexOf(e);
        if (i<0) {
            return false; 
        }
        remove(i);
        return true;
    }

    @Override
    public Object replace(int i, Object e) throws OutOfBoundaryException {
        // TODO Auto-generated method stub
        if (i<0||i>=size){
            throw new OutOfBoundaryException("错误,指定的序号越界。");
        }
        Object obj = elements[i];
        elements[i] = e;
        return obj;
    }

    @Override
    public Object get(int i) throws OutOfBoundaryException {
        // TODO Auto-generated method stub
        if (i<0||i>=size){
            throw new OutOfBoundaryException("错误,指定的序号越界。");
        }
        return elements[i];
    }
    


}

5.上面的代码中我们的函数都抛出了一个异常，这个异常是我们自己定义的。

public class OutOfBoundaryException extends RuntimeException{

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