顺序表相关操作（增，删，改，查等）

我们用Java代码来实现顺序表

 
线性表的概念：
 线性表是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表，链表，栈，队列，字符串。

 
  线性表的顺序存储结构是指在计算机中用一组地址连续的存储单元依次存储线性表的各个元素，元素之间的逻辑关系通过存储位置来反映，用这种存储形式存储的线性表称为顺序表。
 
  顺序表：一般情况下采用数组存储。在数组上完成数据的增删改查。

  顺序表一般可以分为：
①静态顺序表（使用定长数组存储）
②动态顺序表（使用动态开辟的数组存储）
  静态顺序表适用于确定知道需要存储多少数据的场景，但静态顺序表的定长数组导致N定大了，空间浪费，开少了又不够用。所以相比之下，动态顺序表更灵活，根据需要动态分配空间。以下我们就说一下动态实现顺序表。
 
 在操作顺序表时我们要注意：
  ①在作插入操作时，首先要判断插入位置是否合理，插入位置不能越界，其次，要先将插入位置及之后的元素统一向后移动，空出来要插入的位置，然后进行插入操作，插入元素之后，计数usedsize++，完成插入。
  ②在作删除操作时，也要先考虑删除的位置是否合理，之后将要删除的元素之后的元素依此向前移动，最后计数usedsize–，完成删除。

 
参考代码如下：

class  MyArrayList{
     //定义数据成员
    public int usedSize; 
    public int[]  elem;
     //定义常量
    public  final int CAPACITY=10;

    //无参构造方法
    public MyArrayList(){
        this.usedSize=0;
        this.elem=new int[CAPACITY];
    }

     //判断是否满
    private boolean isFull(){
        return  this.usedSize == this.elem.length;
    }

    //在pos位置新增元素
   public void add(int pos,int data){
        if(pos<0 || pos>usedSize){
            System.out.println("插入位置不合理");
        }
       for (int i = usedSize-1; i >=pos ; i--) {
           this.elem[i+1]=this.elem[i];
       }
       elem[pos]=data;
       usedSize++;
   }

   //判断是否包含某个元素
    public boolean contains(int toFind){
        for(int i=0;i<usedSize;i++){
            if(this.elem[i]==toFind){
                return true;
            }
        }
        return false;
    }

    //获取pos位置的元素
    public int getPos(int pos) {
        if(pos>usedSize-1 || pos<0){     //pos位置是否合理判断
            return -1;
        }
        return this.elem[pos];
    }

    //查找值返回下标
    public int search(int tofind) {
        for(int i=0; i<usedSize;i++){
            if(this.elem[i]==tofind){
                return i;
            }
        }
        return -1;
    }

    //删除第一次出现的关键字toremove
    public void remove(int toremove) {
        int index=search(toremove);
        if(index==-1){
            System.out.println("没有要删除的数");
        }
        for(int i=index;i<usedSize;i++){
            this.elem[i]=this.elem[i+1];
        }
        this.usedSize--;
    }

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

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

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

}

//测试类
class Test{
    public static void main(String[] args) {
        MyArrayList my=new MyArrayList();
        my.add(0,1);
        my.add(0,2);
        my.add(0,3);
        my.add(1,4);
        my.add(0,5);
        my.display();
        my.remove(5);
        my.display();
        my.remove(1);
        my.display();
        my.remove(4);
        my.display();
        System.out.println("===============");
        my.clear();
        my.display();
    }

}


//打印结果
5 3 4 2 1 
3 4 2 1 
3 4 2 
3 2 
===============

 
 
动态顺序表示意图如下：

  上述代码将顺序表的属性以及顺序表的操作方法都封装在一个类中，而在类外，我们可以通过对象去访问类内的数据和方法。体现了Java的封装特性。