顺序表解析及实现

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组
上完成数据的增删查改。
顺序表一般可以分为：

静态顺序表：使用定长数组存储。
动态顺序表：使用动态开辟的数组存储。

接口实现：
静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多
了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以我们来实现动态顺序表。

public interface ISequence {
//在pos位置插入val
boolean add(int pos,Object data);
//查找关键字key 找到返回key的下标，没有返回null;
int search(Object key);
//查找是否包含关键字key是否在顺序表当中(这个和search有点冲突)
boolean contains(Object key);
//得到pos位置的值
Object getPos(int pos);
//删除第一次出现的关键字key
Object remove(Object key);
//得到顺序表的长度
int size();
//打印顺序表
void display();
//清空顺序表以防内存泄漏
void clear();
}

package www.bittech;

import java.lang.reflect.Array;
import java.util.Arrays;

public class MySequencelmpl implements ISequence {
    private Object[] elem;
    private int usedSize;//有效数据个数
    private static final int DEFAUIL_SIZE=10;
    public MySequencelmpl(){
        this.elem=new Object[DEFAUIL_SIZE];
    }

    private boolean isFull(){
        if(this.usedSize==this.elem.length){
            return true;
        }
        return false;
        //return this.usedSize==this.elem.length;
    }
    @Override
    public boolean add(int pos, Object data) {
        //判断pos位置的合法性
        if(pos<0||pos>this.usedSize){
            return false;
        }else if(isFull()){
            //进行2倍扩容
            this.elem=Arrays.copyOf(this.elem,2*this.elem.length);
        }
        for(int i=this.usedSize-1;i>=pos;i--){
            this.elem[i+1]=this.elem[i];
        }
        this.elem[pos]=data;
        this.usedSize++;
        return true;
    }

    private boolean isEmpty(){
        return this.usedSize==0;
    }
    @Override
    public int search(Object key) {
        if(isEmpty()){
            return -1;
        }
        for(int i=0;i<this.usedSize;i++){
            if(this.elem[i].equals(key)){
                return i;
            }
        }
        return -1;
    }

    @Override
    public boolean contains(Object key) {
        if(isEmpty()){
            return false;
        }
        for(int i=0;i<this.usedSize;i++){
            if(this.elem[i].equals(key)){
                return true;
            }
        }
        return false;
    }

    @Override
    public Object getPos(int pos) {
        if(pos<0||pos>this.usedSize){
            return null;
        }
        return this.elem[pos];
    }

    @Override
    public Object remove(Object key) {
        int index=search(key);
        if(index==-1){
            return null;
        }
        Object date=this.elem[index];
        int i;
        for(i=index;i<this.usedSize-1;i++){
           this.elem[i]=this.elem[i+1];
        }
        this.usedSize--;
        this.elem[i]=null;
        return date;
    }

    @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;
        }
    }
}

顺序表解析及实现

猜你喜欢