顺序表Java实现

T olddata = (T)data[i];
for(int j=i; j<length-1; j++)
data[j] = data[j+1];
data[--length]=null;
return olddata;
} /Βιβλιοθήκη 删除值为o的元素 public T remove(T o){
return Arrays.copyOf(this.data, this.length);
}
//将顺序表转换为类型为E的数组
public T[] toArray(T[] a){
if(a.length < length)
//创建一个与数组a的运行时类型相同的新数组，a的长度可以为0
if(a instanceOf Comparable && b instanceOf Comparable)
return ((Comparable) a).compareTo((Comparable) b);
else
return ((String) a).compareTo((String) b);
else{
data[i] = x;
return true;
}
}
public void add(int i, T x){ //在位置i插入数据元素x
if(length==data.length) grow();//顺序表容量满，用grow()自动增加容量
if(i<0) i=0;
public SeqList(int initLen){//initLen是初始容量
if(initLen <= 0) initLen = 16;
length = 0;
incrementSize = 0;//容量增量
data = new Object[initLen];
}
//默认构造函数
incrementSize = inc;
}
//内部使用，自动增加顺序表容量
private void grow(){
int newsize = data.length + incrementSize;
data = Arrays.copyOf(data, newsize);
}
//取得顺序表下标为i的元素值，即data[i]
return (T[])Arrays.copyOf(this.data, this.length; a.getClass());
System.arraycopy(this.data, 0, a, 0, this.length);//ng.System的静态方法arraycopy()可以实现数组的复制
public T get (int i){
if(i<0 || i>length-1) return null;
return (T)data[i];
}
//修改顺序表下标为i的元素值，即修改data[i]的值
public boolean set(int i, T x){
if(i<0 || i>length-1) return false;
}
else{//查找有效值
for(int i=0; i<length; i++)
if(compare(o,(T)data[i])==0)
return i;
}
return -1;
}
//内部使用，提供数据元素的比较方法
protected int compare(T a, T b){
}
//内部使用，以有序的方式插入数据元素x
private void insertOrder(int end, T x){
if(length==data.length) grow();
int k;
for(k=end-1; k>=0; k--){
if(compare(x, (T)data[k])<0)
public SeqList(){
this(16);//顺序表默认长度设置为16，后期可自动调整
}
//用数组elem初始化顺序表
public SeqList(T[] elem){
length = elem.length;
incrementSize = 0;
data = Arrays.copyOf(elem, length);//数组复制
strb = null;
return s;
}
}
//对顺序表实现排序算法，调用inserOrder函数完成具体插入过程
public void sort(){
for(int i=1; i<=length-1; i++)
inserOrder(i,(T)data[i]);
}
//将顺序表转换为Object数组
public Object[] toArray(){
data[k+1]=data[k];
else break;
}
data[k+1]=x;
}
//以有序方式想顺序表中插入数据元素x，调用inserOrder函数完成实际插入过程
public void addSort(T x){
inserOrder(length,x);
length++;
if(a.length > this.length)
a[length] = null;
}
//将顺序表转换为字符串，便于直接输出顺序表
public String toString(){
StringBuilder strb = new StringBuilder();
strb = strb.append("(");
for(int i=0; i<length-1; i++){
strb = strb.append(data[i].toString()+",");
}
strb=strb.append(data[length-1]+")");
String s = new String(strb);
}
public void setCapacity(int newsize){
data = Arrays.copyOf(data, newsize);
}
//顺序表的最大容量
public int getCapacity(){
return data.length;
}
public void setIncr(int inc){
if(i>length) i=length;
for(int j=length-1; j>=i; j--)
data[j+1] = data[j];
data[i] = x;
length++;
}
public void add(T x){ //在表尾增加数据元素x
if(length==data.length) grow();
data[length] = x;
length++;
}
public void append(T x){ //在表尾增加数据元素x
add(x);
}
//删除下标为i的元素
public T remove(int i){
if(i<0 || i>length-1)
throw new IndexOutOfBoundsException("下标越界 i= " + i);
int i=indexOf(o);
return remove(i);
}
//清除整个顺序表
public void clear(){
//Let gc do its work
for(int i=0; i<length; i++)
data[i]=null;//让Java虚拟机的垃圾收集器自动处理
length=0;
}
//查找值为o的数据元素的下标，使用顺序查找算法
public int indexOf(T o){
if(o == null){ //查找null值
for(int i=0; i<length; i++)
if(data[i]==null)
return i;