数据结构（顺序表）

顺序表

概念

顺序表是用一段物理地址的存储单元依次存储数据元素的线性数据。一般情况下才有数组进行存储，在数组上完成增数据的删改查。顺序表分为静态顺序表和动态顺序表。

顺序表的特点是逻辑和物理上是连续的。

顺序表的实现:

/**
 * @title: List  （顺序表）
 * @projectName NumZu
 * @description: TODO
 * @author GuiYee}
 * @date 2021/4/13 13:15
 */
public class SeqList{
    private int[] elme;
    private int usedSize;

    public SeqList(){
        this.elme = new int[10];
    }

    //打印
    public void display(){
        for (int i = 0; i<this.usedSize;i++){
            System.out.print(this.elme[i]+" ");
        }
        System.out.println();
    }
    //新增元素
    public void add(int arr ,int data){
        if(this.elme.length == this.usedSize){
            System.out.println("顺序表满了");
            return;
        }
        if(arr<0 || arr>this.usedSize){
            System.out.println("arr位置不合法");
            return;
        }
        for (int i = this.usedSize-1; i >=arr ; i--) {
            this.elme[i+1] = this.elme[i];
        }
        this.elme[arr] = data;
        this.usedSize++;
    }
    //判断是否有元素
    public boolean contains(int toFind){
        for (int i = 0; i <this.usedSize ; i++) {
            if(this.elme[i] == toFind){
                return true;
            }
        }
        return false;
    }
    //某个元素对应的位置
    public int search(int toFind){
        for (int i = 0; i <this.usedSize ; i++) {
            if(this.elme[i] == toFind){
                return i;
            }
        }
        return -1;
    }
    //获取arr位置上的元素
    public int getArr(int arr){
        if(this.usedSize==0) {
                return -1;
        }
        if(arr<0 || arr>this.usedSize){
            return -1;
        }
        return this.elme[arr];
    }

    //更新
    public void setArr(int arr,int value){
        if(this.usedSize==0) {
            return ;
        }
        if(arr<0 || arr>this.usedSize){
            return ;
        }
         this.elme[arr] = value;
    }

    //删除关键字
    public void remove(int key){
        int index = search(key);
        if(index == -1){
            System.out.println("查找的关键字："+key+"不存在");
        }
        for (int i = index; i <=this.usedSize; i++) {
            this.elme[i] = this.elme[i+1];
        }
        this.usedSize--;
    }

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

    //删除
    public void clear(){
        this.usedSize =0;
    }


    public static void main(String[] args) {
        SeqList seqList = new SeqList();
        seqList.add(0,1);
        seqList.add(1,2);
        seqList.add(2,3);
        seqList.add(3,4);
        seqList.display();
        System.out.println("***********");
        seqList.add(0,99);
        seqList.add(5,100);
        seqList.display();
        System.out.println("***********");
        Stem.out.println(seqList.contains(2));
        seqList.remove(1);
        seqList.display();
        System.out.println("***********");
        System.out.println(seqList.getArr(3));
        seqList.setArr(1,1001);
        seqList.display();
        System.out.println("***********");
        System.out.println(seqList.search(1001));
        System.out.println("***********");
        System.out.println(seqList.size());
       

  }
}

注意
1、顺序表中间个开始的插入删除，时间复杂度为0(N)
2、当顺序表便满了需要扩容一下可以实现

public void add(int arr ,int data){
        if(this.elme.length == this.usedSize){
            System.out.println("顺序表满了");
            this.elme=ArraycopyOf(this.emle,2*this.elme.length);
            //return;
        }
     }