顺序表的总结

顺序表： 线性表的顺序存储是用一组连续的内存单元依次存放线性表的数据元素，元素在内存的物理存储次序与它们在线性表中的逻辑次序相同

顺序表的一些基本操作：
插入：在顺序表元素ai位置插入元素x,首先必须将元素ai,a(i+1),…,a(n-1)向后移动，空出一个位置，然后将x插入。

删除：删除顺序表ai，必须将元素a(i+1),a(i+2),…,a(n-1)向前移动。原来第i个位置变为a(i+1).

一些基本操作的代码实现：
接口类中声明方法：

package inte;

public interface ISequence {
    boolean add(int pos, Object data);     //在pos位置插入val

    int search(Object key);  //查找关键字key,找到返回key的下标，没有返回null
    boolean contains(Object key);//查找关键字key是否在顺序表当中
    boolean getPos(int pos);     //得到pos位置的值
    Object remove(Object key);   //删除第一次出现的关键字key
    int size();  //得到顺序表的长度
    void display();  //打印顺序表
    void clear();  //清空


}

具体实现类：

package inte;

import inte.ISequence;

import java.util.Arrays;

public class MySequenceIml implements ISequence {
    private Object[] elem;
    private int usedSize;
    private static final int DEFAULT_SIZE=10;
    public MySequenceIml(){
        this.elem=new Object[DEFAULT_SIZE];
        this.usedSize=0;
    }
    public boolean isFull(){
        if(this.usedSize==this.elem.length){
            return true;}
            return false;
    }
    @Override
    public boolean add(int pos, Object data) {
        if(pos<0|| pos>this.usedSize){
            return false;
        }
        if(isFull()){
        this.elem= Arrays.copyOf(this.elem,this.elem.length*2);   //长度扩大二倍
        }
        for(int i=this.usedSize-1;i>=pos;i--){    //给第一个插入数据
            this.elem[i+1]=this.elem[i];

            }
            this.elem[pos]=data;
        this.usedSize++;   //放完后长度加1
        return true;
    }

    public boolean isEmpty(){
        if(this.usedSize==0){
            return true;
        }
        return false;
    }
    @Override
    public int search(Object key) {
        if(key==null){
            return -1;
        }
        if(isEmpty()){
            throw new UnsupportedOperationException("顺序表为空");
        }
        for(int i=0;i<this.usedSize;i++)
        {
            if(this.elem[i].equals(key)) {   //Object是引用类型
                return i;
            }

        }
        return -1;
    }

    @Override
    public boolean contains(Object key) {
        if(key==null){
            return false;
        }
        if(isEmpty()){
            throw new UnsupportedOperationException("顺序表为空");
        }
        for(int i=0;i<this.usedSize;i++) {
            if (this.elem[i].equals(key)) {   //Object是引用类型
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean getPos(int pos) {
        if(pos<0||pos>=this.usedSize||isEmpty()){

        }
        return false;
    }

    @Override  //删除之前，保存需要删除的值作为返回值
    public Object remove(Object key) {
        int index=search(key);
        if(index==-1){
            return null;
        }
        Object data=this.elem[index];
        int i=0;
        for(i=index;i<this.usedSize-1;i++){
            this.elem[i]=this.elem[i+1];

        }
        this.elem[i+1]=null;
        this.usedSize--;
        return data;   //保存了删除的数据
    }

    @Override
    public int size() {
        return this.usedSize;
    }

    @Override
    public void display() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i]+" ");
        }
        System.out.println();
    }



    @Override
    public void clear() {      //回收内存
     for(int i=0;i<this.usedSize;i++){
         this.elem[i]=null;
     }
        this.usedSize=0;
    }

}

测试：

package inte;

public class TestDemo3 {
    public static void main(String[] args) {
        MySequenceIml MySequence=new MySequenceIml();
        MySequence.add(0,25);
        MySequence.add(1,"ZH");
        MySequence.add(2,38);
        MySequence.add(1,"lovely");
        MySequence.display();
        MySequence.getPos(2);
        System.out.println(MySequence.remove("lovely"));
        MySequence.display();
        System.out.println(MySequence.contains(38));//true
        MySequence.clear();
        MySequence.display();
    }
    }

运行结果：