JAVA中顺序表的实现

---

前言

数据结构是计算机科学专业的核心课程之一，面向对象方法已经成为目前系统开发和程序设计的主流模式，线性表是一种在实际广泛使用的数据结构。

---

先创建一个show方法，以便后面输出使用

**public void  show(){
            for (int i = 0; i <usedSize ; i++) {
                System.out.print(array[i]+" ");
            }
            System.out.println( );
        }**

实现add方法： 顺序表的add方法，在pos位置添加一个数

 **int[] array;
    int usedSize = 0;  //数组元素个数
    public OOPTest() {
        this.array = new int[6];
    }
    //在pos 位置新增元素
    public void add(int pos, int data) {
        //判断pos新增位置 ，看是否超过数组长度
        if (isfull()) {
            System.out.println("数组满了！需要扩容");
            this.array = Arrays.copyOf(this.array,2*(array.length));
        }
        //判断pos位置的合法性，不能为负数，不能超过数组的长度
        if (pos < 0 || pos > usedSize){
            System.out.println("pos位置不合法！");
            return;
        }
       /* //pos == usesize?
        if (pos == usedSize){
            array[pos] = data;
            this.usedSize++;      //每放一个元素usedsize +1
            return;
        }*/   // 优化
        //从后往前挪数组元素
        for (int i = usedSize-1; i >=pos ; i--) {   //i依次往后挪动 在i等于要放的pos的位置停止，将pos位置移动后就不用再往前
            array[i+1] = array[i];                 //如果i大于0，那每次都会移到0位置，
        }
         this.array[pos] = data;
         this.usedSize++;      //每放一个元素usedsize +1
        }
        //判断数组元素个数满了没有
        public boolean isfull(){
            if (this.usedSize ==this.array.length) {
                return true;
            }
            return false;
        }**

实现contains方法 ：判断顺序表中是否包含某个元素

**public boolean contains(int toFind){
            for (int i = 0; i <usedSize ; i++)
             if (array[i]==toFind){
                 return true;
             }
            return false;
        }**

实现search方法： 寻找某个元素对应的位置

**public int search(int toFind) {
            for (int i = 0; i < usedSize; i++)
                if (array[i] == toFind) {
                    return i;
                }
            return -1;
        }**

实现getPos方法： 获取pos位置

 **public int getPos(int pos){
            for (int i = 0; i < usedSize; i++){
                if (i == pos){
                    return i;
                }
            }
            return -1;
        }**

实现setPos方法： 给pos位置的元素设为value

  **public void setPos(int pos, int value) {
            if (pos < 0 || pos > usedSize) {
                System.out.println("pos位置不合法！");
                return;
            }
            for (int i = 0; i < usedSize; i++) {
                if (i == pos) {
                    array[i] = value;
                }
            }
        }**

实现remove方法： 去除顺序表中的某一元素

 **public void  remove(int  toRemove) {
        boolean flag = true;
        for (int i = 0; i < usedSize - 1; i++) {
            if (array[i] == toRemove) {
                array[i] = array[i + 1];
                flag = false;
            }
            }
        if (flag==false){
            array[usedSize-1]=0;
            usedSize--;
            return;
        }
        System.out.println("没有找到该元素");
        }**

实现size方法和clean方法获取顺序表长度以及清空顺序表

 **//获取顺序表长度
        public int size() {
        return usedSize;
        }
        //清空顺序表
    public void clean(){
        for (int i = 0; i < usedSize - 1; i++){
            array[i]=0;
        }
        usedSize=0;
    }**

---

总结

顺序表，是采用一段连续的区域存储数据的线性表。
1.顺序表中间/头部的插入删除，时间复杂度为O（n）；
2.增容需要申请空间，拷贝数据，释放就空间，消耗比较大；
3.增容一般呈2倍增长，势必会有空间浪费。