資料結構之順序表： 

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[i]) < 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]

    }
}
 

順序表的合併操作雖然完成了，但仍存在一些問題，需要繼續完善。