数据结构顺序表类

数据结构顺序表类

public class SeqList<T> extends Object{
    protected int n;    //顺序表元素个数
    protected Object[] element; //对象数组存储顺序表的数据元素，保护成员
    private static final int MIN_CAPACITY=16;    //常量，指定element数组容量的最小值

    /*构造空表*/
    public SeqList(int length){
        if (length<MIN_CAPACITY)
            length=MIN_CAPACITY;
        this.element=new Object[length];
        this.n=0;
    }
    /*创建默认容量的空表，构造方法重载*/
    public SeqList(){
        this(MIN_CAPACITY);
    }
    /*构造顺序表，由values数组提供元素，忽略其中空对象*/
    public SeqList(T[] values){
        //创建两倍values数组容量的空表，若values==null，抛出NullPointerException异常
        this(values.length*2);
        for (int i=0;i<values.length;i++){
            if (values[i]!=null)
                element[n++]=values[i];
        }
    }
    /*判断是否为空*/
    public boolean isEmpty(){
        return n==0;
    }
    /*返回元素个数*/
    public int size(){
        return n;
    }
    /*取元素*/
    public T get(int i){
        if (i>=0 && i<n){
            return (T)element[i];
        }
        return null;
    }
    /*存元素*/
    public void set(int i,T x){
        if (x==null)
            throw new NullPointerException("x==null");
        if (i>=0 && i<n)
            element[i]=x;
        else
            throw new IndexOutOfBoundsException();
    }
    /*返回所有元素的描述字符串*/
    public String toString(){
        String str=this.getClass().getName() + "(";
        if (this.n>0)
            str += element[0].toString();
        for (int i=1;i<n;i++){
            str += ", " + element[i].toString();
        }
        return str + ")";
    }
    /*插入元素，插入x作为第i个元素*/
    public int insert(int i,T x){
        if (x==null)
            return -1;
        if (i<0)
            i=0;
        if (i>n)
            i=n;
        Object[] source=element;    //数组变量引用赋值，source也引用element数据
        if (n==element.length) {
            //若数组满，则扩充顺序表的数组容量
            element = new Object[source.length * 2];
            for (int j = 0; j < i; j++) {
                this.element[j] = source[j];
            }
        }
            for (int j=n-1;j>=i;j--){
                //从i开始至表尾的元素向后移动，次序从后向前
                element[j+1]=source[j];
            }
            element[i]=x;
            n++;
            return i;   //返回插入元素序号
    }
    public int insert(T x){
        return insert(n,x);
    }
    /*删除元素*/
    public T remove(int i){
        if(i>=0 && i<n){
            T x=(T)element[i];
            for (int j=i;j<n-1;j++){
                element[j]=element[j+1];
            }
            element[n-1]=null;
            n--;
            return x;
        }
        return null;
    }
    /*删除所以元素*/
    public void clear(){
        n=0;    //设置长度为0，未释放空间
    }
    /*查找元素*/
    public int search(T key){
        for (int i=0;i<n;i++)
            if (key.equals(element[i]))
                return i;
            return -1;
    }
    /*顺序表比较相等*/
    public boolean equals(Object obj){
        if (this==obj)  //若this和obj引用同一个顺序表实例，则相等
            return true;
        if (obj instanceof SeqList<?>){
            SeqList<T> list=(SeqList<T>)obj;    //声明list也引用obj所引用的实例
            if (this.n==list.n){    //比较两者长度是否相等
                for (int i=0;i<this.n;i++)
                    if (!this.element[i].equals(list.element[i]))
                        return false;
                    return true;
            }
        }
        return false;
    }
}