顺序表的实现

带泛型的顺序表

package c2_线性表.顺序表的实现;

import java.util.Arrays;

/**
 * @author Wei
 * @create 2021/09/09  15:09
 */

public class SeqList<T> extends Object {

        protected int n;   //顺序表元素个数
        protected Object[] element;   //对象数组存储顺序表的数据元素
        private static int MIN_CAPICITY=16;

        //初始化
        public SeqList(int length) {

            if(length<MIN_CAPICITY) {
                length=MIN_CAPICITY;
            }

            this.element = new Object[length];
            this.n=0; //初始化n

        }

        public SeqList()
        {
            this(MIN_CAPICITY);
        }	//创建默认的空表

        public SeqList(T[] values) {
            this(values.length*2);  //创建两倍values长度的数组

            for(int i=0;i<values.length;i++) {
                if(values[i]!=null) {
                    this.element[this.n++]=values[i];
                }
            }

        } //创建一个两倍长度的数组，此方法可以直接添加新的数组进来


        //插入
        public int insert(int i,T x){

            if(i<0){
                i=0;
            } //数组容错，存放在头数据

            if (i>this.n){ //n为数组长度
                i=this.n;
            } //当插入的位置i大于数组长度时，从末尾插入数据

            Object source[] = element;  //创建一个数组存放原数组

            if(this.n==source.length){
                this.element=new Object[source.length];

                for (int j=0;j<source.length;j++){
                    this.element[j]=source[j];
                } //将原数组元素复制到新的数组中

            }

            for (int j=this.n-1;j>=i;j--){
                this.element[j+1]=source[j];  //复制数组元素，从最后一个位置往后移动直到i
            }

            this.element[i]=x;
            this.n++;
            this.sort();
            return i;

        }

        public int insert(T x){

            return this.insert(this.n,x);

        } //重载方法，从末尾插入数据


        //删除
        public T delete(int i){  //返回第i个元素，0<i<n,返回被删除元素,若i越界，则返回null

            if (i>0 && i<this.n){
                T x =(T)this.element[i];

                for (int j=i;j<this.n-1;j++){
                    this.element[j]=this.element[j+1];
                } //从第i+1个位置开始，元素前移

                this.element[this.n-1]=null;  //数组的最后一个位置为空的 释放实例

                this.n--;  //数组长度-1

                this.sort();
                return x;  //返回被删除对象的引用

            }

            this.sort();
            return null;

        }



        //查找元素
        public int search(T key) {  //若查找到元素则返回元素位置，找不到则返回-1

            for (int i = 0; i < this.n - 1; i++) {

                if (key.equals(this.element[i])) {
                    this.sort();
                    return i;
                }

            }

            this.sort();
            return -1;

        }

        //获取元素
        public T get(int i){ //若i在数组范围内，则返回该位置所在的元素，若数组越界则返回null;

            if (i>=0 && i<this.n-1){
                return (T)this.element[i];
            }

            return null;
        }

        //判空
        public boolean isEmpty(){

            if (this.n==0){
                return true;
            }

            return false;
        }
        //求长度
        public int length(){
            return n;
        }
        //正序遍历
        public  void sort(){
            for (int i=0;i<element.length;i++){
                System.out.print(this.element[i]+" ");
            }
        }

 /* 创建一个顺序表对象，在顺序表对象中存放字符（只有数字字符和英文字符），编写算法删除所有的数字字符。
* 要求：按照下面提示，实现该算法。
* 每找到一个待删点，并不马上删除，而是累计当前待删元素的个数s。
* 于是，对每一个非数字字符，将其前移s个位置。每结点最多移动1次，O(n)。

 */
        public int deleteNumber(T[] elements){
            int count = 0;

            for (int i=0;i<this.n;i++){
                boolean bDeleted = false;

                for (int j=0;i<elements.length;j++){

                    if (elements[j].equals(this.element[i])) {
                        System.out.println(elements[j]);
                        bDeleted = true;
                        count++;
                    }
                }

                if(!bDeleted && count >0){
                    this.element[i-count] = this.element[i];
                }

            }

            this.n -=count;
            return 0;
        }


    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        SeqList<?> seqList = (SeqList<?>) o;

        if (n != seqList.n) return false;
        // Probably incorrect - comparing Object[] arrays with Arrays.equals
        return Arrays.equals(element, seqList.element);
    }

    @Override
    public int hashCode() {
        int result = n;
        result = 31 * result + Arrays.hashCode(element);
        return result;
    }
}