java数据结构之顺序表

java数据结构之顺序表

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数
据的增删查改。
顺序表一般可以分为：
静态顺序表：使用定长数组存储。
动态顺序表：使用动态开辟的数组存储。
静态顺序表适用于确定知道需要存多少数据的场景.
静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用
相比之下动态顺序表更灵活, 根据需要动态的分配空间大小

第一步：定义一个类
int [ ] emul ; 表示数组
int usedSize; 表示数组有效元素个数

第二歩：在 pos 位置新增元素data
1、因为要增加元素，所以要判断是在什么位置增加，并且增加的元素是在有元素的后面增加。POS位置不能在数组0之前增加元素，也不能超过数组(数组[4]之后)的位置增加，所以pos > 0 || pos < usedSize

2、如果数组满了，你要增加元素，就要扩容，将数组扩大到你想要的大小，所以要判断数组是否满了，满了就扩容

3、因为在某一个位置增加，所以要讲这个位置之后的元素全部移动到后一个位置
4、有效元素的个数就要加1， usedSize++

第二歩：删除第一次出现的关键字key
1、删除这个元素，就要判断数组里面是否有这个元素
2、如果有那就将这个这个位置的元素全部向前移动一个位置，将之前的元素覆盖掉

第三歩：判定是否包含某个元素

第四歩：给 pos 位置的元素设为 value
1、改变这个元素，就要判断数组里面是否有这个元素
2、将value的值赋值给POS这个位置的元素

class MyarrayLiet {

    public int[] emul;
    public int usedSize;

    public MyarrayLiet() {
        this.emul = new int[10];
    }
}

实现顺序表：

class MyarrayLiet {

    public int[] emul;
    public int usedSize;

    public MyarrayLiet() {
        this.emul = new int[10];
    }

    // 打印顺序表
    public void display() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(emul[i]+" ");
        }
        System.out.println( );
    }

    //判断POS是否满
    public boolean isFull(){
        if (this.usedSize == 10){
            return true;
        }
        return false;
    }

    // 在 pos 位置新增元素data
    public void add(int pos, int data) {
        //1、判断POS位置是否合法
        if(pos < 0 || pos > this.usedSize){
            System.out.println("pos位置不合法！");
            return ;
        }
        //2、判断POS是否满,满了就要扩容
        if(this.isFull()){
            this.emul = Arrays.copyOf(this.emul,2*emul.length);
        }
        //3、将i位置的值赋给i+1的值
        for (int i = usedSize-1; i >= pos; i--) {
            this.emul[i+1] = this.emul[i];
        }
        this.emul[pos] = data;
        usedSize++;
    }
    //判断是否为空
    public boolean kong(){
        if(this.usedSize == 0){
            return true;
        }
        return false;
    }
    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        //判断是否为空
       if(this.kong()){
           return false;
       }
        for (int i = 0; i < usedSize; i++) {
            if(this.emul[i] == toFind){
                return true;
            }
        }
        return false;
    }

    // 查找某个元素对应的位置
    public int search(int toFind) {
        if(this.kong()){
            return -1;//-1表示没有找到这个元素
        }
        for (int i = 0; i < usedSize; i++) {
            if(this.emul[i] == toFind){
                return i;
            }
        }
        return -1;
    }

    // 获取 pos 位置的元素
    public int getPos(int pos) {
        if(pos < 0 || pos >= usedSize){
            return -1;
        }
        return this.emul[pos];
    }

    // 给 pos 位置的元素设为 value
    public void setPos(int pos, int value) {
        if(pos < 0 || pos >= usedSize){
            System.out.println("pos位置不合法！");
            return;
        }
        this.emul[pos] = value;
    }

    //删除第一次出现的关键字key
    public void remove(int toRemove) {
        if(this.kong()){
            System.out.println("元素为空");
            return ;
        }
        int a = this.search(toRemove);//查找某个元素对应的位置,返回的是元素的下标（位置）
        if(a == -1){
            System.out.println("没有要删除的数！");
            return;
        }
        for(int i = a; i < this.usedSize -1; i++){//将i+1 的元素赋值给i的元素
            this.emul[i] = this.emul[i+1];
        }
        this.usedSize --;
    }

    // 获取顺序表长度
    public int size() {
        return this.usedSize;
    }

    // 清空顺序表
    public void clear() {
        this.usedSize = 0;
    }

}