顺序表的相关操作，插入，删除等

数据结构之顺序表： 

1. 逻辑上相邻的数据，在物理存储的位置上也是相邻的。
2. 存储密度高，需要预先分配空间。后续的代码可以看到。
3. 但是它存储结构跟数组是一样，所以也就不便于插入和删除。当顺序表较大时，插入和删除都会引起大量数据的移动。如果插入和删除频繁操作的话，最好使用链表的数据结构。顺序表一般存储不经常变动的数据。
4. 顺序表的基本操作，如：插入（头插，尾插），删除（头删，尾删），查找；另外，还有一些其他操作，如排序，逆置，合并等等。

//此处为一些基本操作
class MyArrayList<T> {
    private T[] arr;
    private int size;//有效数据个数
    private static final int CAPACITY = 10;

    public T[] getValue() {
        return arr;
    }

    public void setArr(T[] arr) {
        this.arr = arr;
    }

    public MyArrayList() {
        this(CAPACITY);
    }

    public MyArrayList(int n) {
        arr = (T[]) new Object[n];//若该类，类型擦除到Comparable,无法看到Object类，编译报错
        size = 0;
    }
    public int getSize(){
        return size;
    }

    //扩容1.5扩容
    private void grow() {
        int newSize = arr.length + (arr.length >> 1);
        arr = Arrays.copyOf(arr, newSize);
    }

    public boolean isFull() {//判满
        return arr.length == size;
    }

    public void addTail(T value) {//尾插
        grow();
        arr[size++] = value;
    }

    public void remove(T value) {//删除
        int index = contains(value);
        if (index != -1) {//可以找到该值
            for (int j = index; j < size; j++)
                arr[j] = arr[j + 1];
        }
        arr[size] = null;//防止内存泄漏
    }

    public void addHead(T value) {//头插
        if (isFull()) {//已满，扩容
            grow();
        } else if (size == 0) {
            arr[0] = value;
        }
        for (int i = size - 1; i >= 0; i--) {
            arr[i + 1] = arr[i];
        }
        arr[0] = value;
        size++;
    }

    public void remove(int index) {//按位置删除
        if (index < 0 || index > size || size == 0) {
            return;
        } else {
            for (int i = index; i < size; i++) {
                arr[i] = arr[i + 1];
            }
            arr[--size] = null;//先运算再取值arr[size-1] = null;size--;
        }
    }

    public void removeTail() {//尾删
        if (size == 0) {
            return;
        } else {
            arr[--size] = null;
        }
    }

    public int contains(T value) {//查找
        for (int i = 0; i < size; i++) {
            if (arr[i].equals(value)) {
                return i;
            }
        }
        return -1;
    }

    public void show() {//打印
        for (int i = 0; i < size; i++) {
            System.out.println(arr[i].toString());
        }
    }
}

另外，关于逆置，合并等操作，要用到Compareable接口中的compareTo方法，所以需要擦除到Compareable接口中。

class MyArrayList1<T>{
    public static<T>void swap(T[] arr,int i,int j){//交换
        T temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    public static <T extends Comparable>T[] sort (T[] arr) {//排序
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j].compareTo(arr[j + 1]) > 0) {
                    swap(arr, j, j + 1);
                }
            }
        }
        return arr;
    }
    public static<T>int getLength(T[] arr){//计算长度
        int length = 0;
        for(int i = 0 ;i < arr.length;i++){
            if(arr[i] != null) {
                length++;
            }
        }
        return length;
    }
    public <T>void reverse(MyArrayList<T> m){//逆置
        for(int i = 0;i < (m.getSize()>>1);i++){
            //使用交换函数，前后交换
            swap(m.getValue(),i,m.getSize()-i-1);
        }
    }

    public  static <T extends Comparable<T>>T[] insertSort(T[] arr,T value){//插入排序
        int i = 0,j = 0;
        int count = getLength(arr);
        if(count == arr.length){
            arr = Arrays.copyOf(arr,arr.length*2);
        }
        for(i = 0;i < arr.length;i++) {
            if (arr[i].compareTo(value) > 0) {
                break;
            }
        }
        for(j = count-1;j >= i;j--){//移动元素
            arr[j+1] = arr[j];
        }
        arr[i] = value;
        return arr;
    }
    public static <T extends Comparable>T[] merge(T[] arr1,T[] arr2,T[] crr){//两个顺序表合并
        int i = 0;//i控制顺序表arr1
        int j = 0;//j控制arr2
        int k = 0;//k控制新合并的顺序表
        while(i < arr1.length && j < arr2.length){//将arr1和arr2都扫描完
            if(arr1[i].compareTo(arr2[j]) < 0){
                crr[k++] = arr1[i++];
            }else{
                crr[k++] = arr2[j++];
            }
        }
        while(i < arr1.length){//arr1未扫描完
            crr[k++] = arr1[i++];
        }
        while(j < arr2.length){//arr2未扫描完
            crr[k++] = arr2[j++];
        }
        return crr;
    }
    public static void main(String[] args) {
        MyArrayList<Integer> n = new MyArrayList<>();
        n.addHead(4);
        n.addHead(3);
        n.addHead(1);
//        System.out.println("查找到的下标为：" + n.contains(3));
//        n.removeTail();
//        n.remove(2);
//        n.show();

        Integer[] arr = {1,5,4,6};
        Integer[] brr = sort(arr);
        int value = 2;
        Integer[] brr1 = insertSort(arr,value);
        System.out.println(Arrays.toString(brr1));
        Integer[] brr2 = new Integer[15];
        merge(arr,brr1,brr2);
        System.out.println(Arrays.toString(brr2));//[1, 2, 4, 5, 6, null, null, null, 1, 4, 5, 6, null, null, null]

    }
}

顺序表的合并操作虽然完成了，但仍存在一些问题，需要继续完善。