在JAVA中实现顺序表的操作

目录

1.创建一个顺序表

 2.在顺序表中插入元素

3.在顺序表中删除元素

---

1.创建一个顺序表

    这里MyArrayList对象代表一个顺序表

    元素类型是long      

    long[]  数组   

    int size

public class MyArrayList {          
    private long[] array;
    private int size;

    public MyArrayList(){                //初始化顺序表
        array=new long[20];
        size=0;                          //有效元素的个数
        Arrays.fill(array,Long.MIN_VALUE);       //填充无效值
    }
}

 2.在顺序表中插入元素

        插入元素时至少得满足一个条件，那就是必须有空间能够插元素，所以至少得保证能插入一个元素，如果容量不足，那么就需要进行扩容操作

   private void ensureCapacity(){
        if(size<array.length){
            return;
        }

        //进行扩容，1.5-2倍
        int newLength= array.length*2;
        long[] newArray=Arrays.copyOf(array,newLength);
        Arrays.fill(newArray,size,newLength, Long.MIN_VALUE);        
        array=newArray;
    }

     （1）尾插操作   

public void add(long e){
        array[size]=e;            //将要插入的元素赋给array[size],即顺序表的最后一个元素
        size++;                   //插入一个元素后需要对有效值的个数加一
    }

     （2）在指定位置插入

 public void add(int index,long e){
        if(index<0||index>size){                 //此时要对传来的下表进行判断，看是否满足条件
            throw new ArrayIndexOutOfBoundsException();
        }
        ensureCapacity();

        //从末尾开始移动，依次向后移动一位
        for (int i = size;i>index;i--) {
            int j=i;
            array[j]=array[i-1];
        }
        array[index]=e;
        size++;
    }

3.在顺序表中删除元素

        （1）删除指定位置的元素

public void delete(int index){
        if(index<0||index>size){
            throw new ArrayIndexOutOfBoundsException();
        }
        ensureCapacity();

        for (int i = index; i < size; i++) {        //将index后的所有元素向前移动一位，此做法就覆盖了index处的元素
            array[i]=array[i+1];
        }
        size--;                                     //删除一个元素后有效元素的个数应该减一
        array[size]=Long.MIN_VALUE;
    }

        （2）移除顺序表中与目标数相同的所有元素

          思想：用与目标数不同的元素覆盖掉与目标数相同的元素

   //移除所有和目标数相同的数
    public void removeAll(long e){            
        int j=0;                                 //j表示前顺序表与目标数不同的数的个数
        for(int i=0;i<size;i++){            
            if(array[i]!=e) {                    //将于目标数不同的数存起来，与目标数不同的数删除调掉
                array[j++] = array[i];
            }
        }
        size=j;
        Arrays.fill(array,size, array.length,Long.MIN_VALUE);
    }

                首先给定一个顺序表

                 假如目标数为3，从前往后找

在i<2时顺序表的内容并不发生改变，但当i=2时，array[i]==3,此时不执行赋值操作，则j的值并不发生改变，i则变成了3；下一次判断时arra[i]!=3,执行赋值操作，此时array[j]=2,即array[2]=2，就成功移除了原来array[2]处的3，现在顺序表前j个元素为。本次循环结束后j=2，i=3

      

 当i=4时，重复上述操作。此次循环结束后j=3，i=5。顺序表前j个成了下面的样子

          

 最终，j=5，前j个元素为下，而此时也就只剩下了与目标数不同的元素

         

        （3）从前往后找，删除第一个与目标数相同的数

                思想：与移除某个元素的方法类似，只是在找到时就结束遍历

  public void removeFromHead(long e){
        int index=0;                                 //index用来表示目标数的下标
        while(index<size){                    
            if(array[index]==e){                     //判断是否找到目标数
                break;                               //找到就结束遍历
            }
            index++;
        }
        if(index==size){                             //此时表示没找到目标数
            return;
        }
        for(int i=index+1;i<size;i++){                //将目标数以后的元素整体向前移动一位
            int j=i-1;
            array[j]=array[i];
        }
        size--;
        array[size]=Long.MIN_VALUE;
    }

        （4）从后往前找，删除第一个与目标数相同的元素

                思想：与从前往后找类似，只是循环条件不一样

public void removeFromLast(long e){
        int index=size-1;
        while(index>=0){
            if(array[index]==e){
                break;
            }
            index--;
        }
        //判断是否找到
        if(index<0){
            return;
        }
        for(int i=index+1;i<size;i++){
            int j=i-1;
            array[j]=array[i];
        }
        size--;
        array[size]=Long.MIN_VALUE;
    }